From 983dbe722936d661bc11dcf26b44add2e594bbf3 Mon Sep 17 00:00:00 2001 From: Neur0toxine Date: Fri, 14 Jun 2024 17:42:42 +0300 Subject: [PATCH] tests, more docs --- core/logger/api_client_adapter_test.go | 2 +- core/logger/attrs_test.go | 155 ++++++++++++++++++ core/logger/buffer_logger_test.go | 6 +- core/logger/default_test.go | 89 ++++++++++ core/logger/gin_test.go | 37 +++++ .../mg_transport_client_adapter_test.go | 2 +- core/logger/pool_test.go | 18 ++ core/logger/writer_adapter_test.go | 24 +++ core/logger/zabbix_collector_adapter.go | 6 +- core/logger/zabbix_collector_adapter_test.go | 25 +++ core/util/testutil/buffer_logger.go | 10 ++ 11 files changed, 367 insertions(+), 7 deletions(-) create mode 100644 core/logger/attrs_test.go create mode 100644 core/logger/default_test.go create mode 100644 core/logger/gin_test.go create mode 100644 core/logger/pool_test.go create mode 100644 core/logger/writer_adapter_test.go create mode 100644 core/logger/zabbix_collector_adapter_test.go diff --git a/core/logger/api_client_adapter_test.go b/core/logger/api_client_adapter_test.go index 4ad51e7..eb2e6ca 100644 --- a/core/logger/api_client_adapter_test.go +++ b/core/logger/api_client_adapter_test.go @@ -10,7 +10,7 @@ import ( ) func TestAPIClientAdapter(t *testing.T) { - log := newJSONBufferedLogger() + log := newJSONBufferedLogger(nil) client := retailcrm.New("https://example.com", "test_key").WithLogger(APIClientAdapter(log.Logger())) client.Debug = true diff --git a/core/logger/attrs_test.go b/core/logger/attrs_test.go new file mode 100644 index 0000000..c3fdcf5 --- /dev/null +++ b/core/logger/attrs_test.go @@ -0,0 +1,155 @@ +package logger + +import ( + "bytes" + "errors" + "fmt" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + "io" + "net/http" + "testing" +) + +func TestErr(t *testing.T) { + var cases = []struct { + source interface{} + expected string + }{ + { + source: nil, + expected: "", + }, + { + source: errors.New("untimely error"), + expected: "untimely error", + }, + } + + for _, c := range cases { + val := Err(c.source) + assert.Equal(t, c.expected, func() string { + if val.String != "" { + return val.String + } + if val.Interface != nil { + return fmt.Sprintf("%s", val.Interface) + } + return "" + }()) + assert.Equal(t, ErrorAttr, val.Key) + } +} + +func TestHandler(t *testing.T) { + val := Handler("handlerName") + assert.Equal(t, HandlerAttr, val.Key) + assert.Equal(t, "handlerName", val.String) +} + +func TestHTTPStatusCode(t *testing.T) { + val := HTTPStatusCode(http.StatusOK) + assert.Equal(t, HTTPStatusAttr, val.Key) + assert.Equal(t, http.StatusOK, int(val.Integer)) +} + +func TestHTTPStatusName(t *testing.T) { + val := HTTPStatusName(http.StatusOK) + assert.Equal(t, HTTPStatusNameAttr, val.Key) + assert.Equal(t, http.StatusText(http.StatusOK), val.String) +} + +func TestBody(t *testing.T) { + var cases = []struct { + input interface{} + result interface{} + }{ + { + input: "", + result: nil, + }, + { + input: nil, + result: nil, + }, + { + input: "ooga booga", + result: "ooga booga", + }, + { + input: `{"success":true}`, + result: map[string]interface{}{"success": true}, + }, + { + input: []byte{}, + result: nil, + }, + { + input: nil, + result: nil, + }, + { + input: []byte("ooga booga"), + result: "ooga booga", + }, + { + input: []byte(`{"success":true}`), + result: map[string]interface{}{"success": true}, + }, + { + input: newReaderMock(func(p []byte) (n int, err error) { + return 0, io.EOF + }), + result: nil, + }, + { + input: newReaderMockData([]byte{}), + result: nil, + }, + { + input: newReaderMockData([]byte("ooga booga")), + result: "ooga booga", + }, + + { + input: newReaderMockData([]byte(`{"success":true}`)), + result: map[string]interface{}{"success": true}, + }, + } + for _, c := range cases { + val := Body(c.input) + assert.Equal(t, BodyAttr, val.Key) + + switch assertion := c.result.(type) { + case string: + assert.Equal(t, assertion, val.String) + case int: + assert.Equal(t, assertion, int(val.Integer)) + default: + assert.Equal(t, c.result, val.Interface) + } + } +} + +type readerMock struct { + mock.Mock +} + +func newReaderMock(cb func(p []byte) (n int, err error)) io.Reader { + r := &readerMock{} + r.On("Read", mock.Anything).Return(cb) + return r +} + +func newReaderMockData(data []byte) io.Reader { + return newReaderMock(bytes.NewReader(data).Read) +} + +func (m *readerMock) Read(p []byte) (n int, err error) { + args := m.Called(p) + out := args.Get(0) + if cb, ok := out.(func(p []byte) (n int, err error)); ok { + return cb(p) + } + return args.Int(0), args.Error(1) +} diff --git a/core/logger/buffer_logger_test.go b/core/logger/buffer_logger_test.go index 7c0b193..a36e5db 100644 --- a/core/logger/buffer_logger_test.go +++ b/core/logger/buffer_logger_test.go @@ -29,8 +29,10 @@ type jSONRecordScanner struct { buf *bufferLogger } -func newJSONBufferedLogger() *jSONRecordScanner { - buf := newBufferLogger() +func newJSONBufferedLogger(buf *bufferLogger) *jSONRecordScanner { + if buf == nil { + buf = newBufferLogger() + } return &jSONRecordScanner{scan: bufio.NewScanner(buf), buf: buf} } diff --git a/core/logger/default_test.go b/core/logger/default_test.go new file mode 100644 index 0000000..acd4f47 --- /dev/null +++ b/core/logger/default_test.go @@ -0,0 +1,89 @@ +package logger + +import ( + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/suite" + "go.uber.org/zap" + "testing" +) + +type TestDefaultSuite struct { + suite.Suite +} + +func TestDefault(t *testing.T) { + suite.Run(t, new(TestDefaultSuite)) +} + +func (s *TestDefaultSuite) TestNewDefault_OK() { + jsonLog := NewDefault("json", false) + consoleLog := NewDefault("console", true) + + s.Assert().NotNil(jsonLog) + s.Assert().NotNil(consoleLog) +} + +func (s *TestDefaultSuite) TestNewDefault_Panic() { + s.Assert().PanicsWithValue("unknown logger format: rar", func() { + NewDefault("rar", false) + }) +} + +func (s *TestDefaultSuite) TestWith() { + log := newBufferLogger() + log.With(zap.String(HandlerAttr, "Handler")).Info("test") + items, err := newJSONBufferedLogger(log).ScanAll() + + s.Require().NoError(err) + s.Require().Len(items, 1) + s.Assert().Equal("Handler", items[0].Handler) +} + +func (s *TestDefaultSuite) TestWithLazy() { + log := newBufferLogger() + log.WithLazy(zap.String(HandlerAttr, "Handler")).Info("test") + items, err := newJSONBufferedLogger(log).ScanAll() + + s.Require().NoError(err) + s.Require().Len(items, 1) + s.Assert().Equal("Handler", items[0].Handler) +} + +func (s *TestDefaultSuite) TestForHandler() { + log := newBufferLogger() + log.ForHandler("Handler").Info("test") + items, err := newJSONBufferedLogger(log).ScanAll() + + s.Require().NoError(err) + s.Require().Len(items, 1) + s.Assert().Equal("Handler", items[0].Handler) +} + +func (s *TestDefaultSuite) TestForConnection() { + log := newBufferLogger() + log.ForConnection("connection").Info("test") + items, err := newJSONBufferedLogger(log).ScanAll() + + s.Require().NoError(err) + s.Require().Len(items, 1) + s.Assert().Equal("connection", items[0].Connection) +} + +func (s *TestDefaultSuite) TestForAccount() { + log := newBufferLogger() + log.ForAccount("account").Info("test") + items, err := newJSONBufferedLogger(log).ScanAll() + + s.Require().NoError(err) + s.Require().Len(items, 1) + s.Assert().Equal("account", items[0].Account) +} + +func TestAnyZapFields(t *testing.T) { + fields := AnyZapFields([]interface{}{zap.String("k0", "v0"), "ooga", "booga"}) + require.Len(t, fields, 3) + assert.Equal(t, zap.String("k0", "v0"), fields[0]) + assert.Equal(t, zap.String("arg1", "ooga"), fields[1]) + assert.Equal(t, zap.String("arg2", "booga"), fields[2]) +} diff --git a/core/logger/gin_test.go b/core/logger/gin_test.go new file mode 100644 index 0000000..3c04067 --- /dev/null +++ b/core/logger/gin_test.go @@ -0,0 +1,37 @@ +package logger + +import ( + "github.com/gin-gonic/gin" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "net/http" + "net/http/httptest" + "testing" +) + +func TestGinMiddleware(t *testing.T) { + log := newBufferLogger() + rr := httptest.NewRecorder() + r := gin.New() + r.Use(GinMiddleware(log)) + r.GET("/mine", func(c *gin.Context) { + c.JSON(http.StatusOK, gin.H{}) + }) + r.ServeHTTP(rr, httptest.NewRequest(http.MethodGet, "/mine", nil)) + + require.Equal(t, http.StatusOK, rr.Code) + items, err := newJSONBufferedLogger(log).ScanAll() + require.NoError(t, err) + require.Len(t, items, 1) + require.NotEmpty(t, items[0].Context) + assert.NotEmpty(t, items[0].Context["startTime"]) + assert.NotEmpty(t, items[0].Context["endTime"]) + assert.True(t, func() bool { + _, ok := items[0].Context["latency"] + return ok + }()) + assert.NotEmpty(t, items[0].Context["remoteAddress"]) + assert.NotEmpty(t, items[0].Context[HTTPMethodAttr]) + assert.NotEmpty(t, items[0].Context["path"]) + assert.NotEmpty(t, items[0].Context["bodySize"]) +} diff --git a/core/logger/mg_transport_client_adapter_test.go b/core/logger/mg_transport_client_adapter_test.go index 262e389..e88aec0 100644 --- a/core/logger/mg_transport_client_adapter_test.go +++ b/core/logger/mg_transport_client_adapter_test.go @@ -11,7 +11,7 @@ import ( func TestMGTransportClientAdapter(t *testing.T) { httpClient := &http.Client{} - log := newJSONBufferedLogger() + log := newJSONBufferedLogger(nil) client := v1.NewWithClient("https://mg.dev", "test_token", httpClient). WithLogger(MGTransportClientAdapter(log.Logger())) client.Debug = true diff --git a/core/logger/pool_test.go b/core/logger/pool_test.go new file mode 100644 index 0000000..5509847 --- /dev/null +++ b/core/logger/pool_test.go @@ -0,0 +1,18 @@ +package logger + +import ( + "github.com/stretchr/testify/assert" + "testing" +) + +func TestPool(t *testing.T) { + p := NewPool[*uint8](func() *uint8 { + item := uint8(22) + return &item + }) + + val := p.Get() + assert.Equal(t, uint8(22), *val) + assert.Equal(t, uint8(22), *p.Get()) + p.Put(val) +} diff --git a/core/logger/writer_adapter_test.go b/core/logger/writer_adapter_test.go new file mode 100644 index 0000000..8007e02 --- /dev/null +++ b/core/logger/writer_adapter_test.go @@ -0,0 +1,24 @@ +package logger + +import ( + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "go.uber.org/zap" + "testing" +) + +func TestWriterAdapter(t *testing.T) { + log := newBufferLogger() + adapter := WriterAdapter(log, zap.InfoLevel) + + msg := []byte("hello world") + total, err := adapter.Write(msg) + require.NoError(t, err) + require.Equal(t, total, len(msg)) + + items, err := newJSONBufferedLogger(log).ScanAll() + require.NoError(t, err) + require.Len(t, items, 1) + assert.Equal(t, "hello world", items[0].Message) + assert.Equal(t, "INFO", items[0].LevelName) +} diff --git a/core/logger/zabbix_collector_adapter.go b/core/logger/zabbix_collector_adapter.go index e81345e..f33face 100644 --- a/core/logger/zabbix_collector_adapter.go +++ b/core/logger/zabbix_collector_adapter.go @@ -13,10 +13,10 @@ type zabbixCollectorAdapter struct { func (a *zabbixCollectorAdapter) Errorf(format string, args ...interface{}) { baseMsg := "cannot send metrics to Zabbix" switch format { - case "cannot send metrics to Zabbix: %v": - baseMsg = "cannot stop collector" - fallthrough case "cannot stop collector: %s": + baseMsg = "cannot stop Zabbix collector" + fallthrough + case "cannot send metrics to Zabbix: %v": var err interface{} if len(args) > 0 { err = args[0] diff --git a/core/logger/zabbix_collector_adapter_test.go b/core/logger/zabbix_collector_adapter_test.go new file mode 100644 index 0000000..bd3633d --- /dev/null +++ b/core/logger/zabbix_collector_adapter_test.go @@ -0,0 +1,25 @@ +package logger + +import ( + "errors" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "testing" +) + +func TestZabbixCollectorAdapter(t *testing.T) { + log := newBufferLogger() + adapter := ZabbixCollectorAdapter(log) + adapter.Errorf("highly unexpected error: %s", "unexpected error") + adapter.Errorf("cannot stop collector: %s", "app error") + adapter.Errorf("cannot send metrics to Zabbix: %v", errors.New("send error")) + + items, err := newJSONBufferedLogger(log).ScanAll() + require.NoError(t, err) + require.Len(t, items, 3) + assert.Equal(t, "highly unexpected error: unexpected error", items[0].Message) + assert.Equal(t, "cannot stop Zabbix collector", items[1].Message) + assert.Equal(t, "app error", items[1].Context[ErrorAttr]) + assert.Equal(t, "cannot send metrics to Zabbix", items[2].Message) + assert.Equal(t, "send error", items[2].Context[ErrorAttr]) +} diff --git a/core/util/testutil/buffer_logger.go b/core/util/testutil/buffer_logger.go index 9df5871..5659ede 100644 --- a/core/util/testutil/buffer_logger.go +++ b/core/util/testutil/buffer_logger.go @@ -26,6 +26,16 @@ type BufferedLogger interface { } // BufferLogger is an implementation of the BufferedLogger. +// +// BufferLogger can be used in tests to match specific log messages. It uses JSON by default (hardcoded for now). +// It implements fmt.Stringer and provides an adapter to the underlying buffer, which means it can also return +// Bytes(), can be used like io.Reader and can be cleaned using Reset() method. +// +// Usage: +// +// log := NewBufferedLogger() +// // Some other code that works with logger. +// fmt.Println(log.String()) type BufferLogger struct { logger.Default buf LockableBuffer