feat: added "Capture" middleware (#9)

* feat: added "Capture" middleware

* feat: added test for handler func in slogt package

Author: Semior001

.golangci.yml

@@ -26,7 +26,6 @@ linters-settings:
 linters:
   enable:
     - megacheck
-    - revive
     - govet
     - unconvert
     - unused

accum_test.go

@@ -10,21 +10,14 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-type handlerFunc func(ctx context.Context, rec slog.Record) error
-
-func (f handlerFunc) Handle(ctx context.Context, rec slog.Record) error { return f(ctx, rec) }
-func (handlerFunc) WithAttrs([]slog.Attr) slog.Handler                  { return NopHandler() }
-func (handlerFunc) WithGroup(string) slog.Handler                       { return NopHandler() }
-func (handlerFunc) Enabled(context.Context, slog.Level) bool            { return true }
-
 func TestAccumulator_Handle(t *testing.T) {
 	t.Run("test", func(t *testing.T) {
 		lg := slog.New(slogt.Handler(t))
 		lg.WithGroup("abacaba").Info("test")
 	})
 
 	t.Run("accumulate only attributes", func(t *testing.T) {
-		acc := Accumulator(handlerFunc(func(ctx context.Context, rec slog.Record) error {
+		acc := Accumulator(slogt.HandlerFunc(func(ctx context.Context, rec slog.Record) error {
 			var attrs []slog.Attr
 			rec.Attrs(func(attr slog.Attr) bool {
 				attrs = append(attrs, attr)
@@ -53,7 +46,7 @@ func TestAccumulator_Handle(t *testing.T) {
 	})
 
 	t.Run("accumulate groups and attributes", func(t *testing.T) {
-		acc := Accumulator(handlerFunc(func(ctx context.Context, rec slog.Record) error {
+		acc := Accumulator(slogt.HandlerFunc(func(ctx context.Context, rec slog.Record) error {
 			var attrs []slog.Attr
 			rec.Attrs(func(attr slog.Attr) bool {
 				attrs = append(attrs, attr)

slogm/capture.go

@@ -0,0 +1,46 @@
+package slogm
+
+import (
+	"context"
+	"log/slog"
+
+	"github.com/cappuccinotm/slogx"
+)
+
+// Capturer is an interface for capturing log records.
+type Capturer interface {
+	Push(slog.Record)
+	Records() []slog.Record
+	Close() error
+}
+
+// ChannelCapturer is a channel that captures log records.
+type ChannelCapturer chan slog.Record
+
+// Push adds a record to the channel.
+func (c ChannelCapturer) Push(rec slog.Record) { c <- rec }
+
+// Close closes the channel.
+func (c ChannelCapturer) Close() error {
+	close(c)
+	return nil
+}
+
+// Records returns all captured records for this moment.
+func (c ChannelCapturer) Records() []slog.Record {
+	var records []slog.Record
+	for len(c) > 0 {
+		records = append(records, <-c)
+	}
+	return records
+}
+
+// Capture returns a middleware that captures log records.
+func Capture(capt Capturer) slogx.Middleware {
+	return func(next slogx.HandleFunc) slogx.HandleFunc {
+		return func(ctx context.Context, rec slog.Record) error {
+			capt.Push(rec)
+			return next(ctx, rec)
+		}
+	}
+}

slogm/capture_test.go

@@ -0,0 +1,36 @@
+package slogm
+
+import (
+	"bytes"
+	"log/slog"
+	"testing"
+
+	"github.com/cappuccinotm/slogx"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCapture(t *testing.T) {
+	ch := make(ChannelCapturer, 2)
+	buf := bytes.NewBuffer(nil)
+	h := slog.Handler(slog.NewTextHandler(buf, &slog.HandlerOptions{}))
+	h = slogx.NewChain(h, Capture(ch))
+	lg := slog.New(h)
+	lg.Info("test",
+		slog.String("key", "value"),
+		slog.Group("g1",
+			slog.String("a", "1"),
+		),
+	)
+
+	records := ch.Records()
+	require.NoError(t, ch.Close())
+
+	assert.Equal(t, []slog.Attr{
+		slog.String("key", "value"),
+		slog.Group("g1",
+			slog.String("a", "1"),
+		),
+	}, slogx.Attrs(records[0]))
+	require.NotEmpty(t, buf.String())
+}

slogt/testhandler.go

@@ -0,0 +1,16 @@
+package slogt
+
+import (
+	"context"
+	"log/slog"
+)
+
+// HandlerFunc is a function that implements Handler interface.
+// If consumer uses it with slogx.Accumulator, then it can completely capture log records
+// and check them in tests.
+type HandlerFunc func(ctx context.Context, rec slog.Record) error
+
+func (f HandlerFunc) Handle(ctx context.Context, rec slog.Record) error { return f(ctx, rec) }
+func (f HandlerFunc) WithAttrs([]slog.Attr) slog.Handler                { return f }
+func (f HandlerFunc) WithGroup(string) slog.Handler                     { return f }
+func (f HandlerFunc) Enabled(context.Context, slog.Level) bool          { return true }

slogt/testhandler_test.go

@@ -0,0 +1,24 @@
+package slogt
+
+import (
+	"context"
+	"log/slog"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestHandlerFunc_Handle(t *testing.T) {
+	called := 0
+	f := HandlerFunc(func(ctx context.Context, rec slog.Record) error {
+		called++
+		assert.Empty(t, rec)
+		return nil
+	})
+	assert.True(t, f.Enabled(context.Background(), slog.LevelInfo))
+	require.NoError(t, f.Handle(context.Background(), slog.Record{}))
+	require.NoError(t, f.WithGroup("group").Handle(context.Background(), slog.Record{}))
+	require.NoError(t, f.WithAttrs([]slog.Attr{}).Handle(context.Background(), slog.Record{}))
+	assert.Equal(t, 3, called)
+}

slogt/testing.go slogt/thandler.go

@@ -3,9 +3,8 @@ package slogt
 
 import (
 	"fmt"
-	"strings"
-
 	"log/slog"
+	"strings"
 )
 
 type testingOpts struct {

slogt/testing_test.go slogt/thandler_test.go

@@ -2,12 +2,12 @@ package slogt
 
 import (
 	"fmt"
+	"log/slog"
 	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"log/slog"
 )
 
 func Test_TestHandler(t *testing.T) {
@@ -19,7 +19,7 @@ func Test_TestHandler(t *testing.T) {
 		assert.Len(t, tm.rows, 1, "should be 1 row")
 		assert.Contains(t, tm.rows[0], "t=")
 		assert.Contains(t, tm.rows[0], fmt.Sprintf(" l=%s", slog.LevelDebug.String()))
-		assert.Contains(t, tm.rows[0], " s=testing_test.go:17")
+		assert.Contains(t, tm.rows[0], " s=thandler_test.go:17")
 		assert.Contains(t, tm.rows[0], fmt.Sprintf(" %s=test", slog.MessageKey))
 		assert.Contains(t, tm.rows[0], " key=value")
 
@@ -36,7 +36,7 @@ func Test_TestHandler(t *testing.T) {
 		assert.Equal(t, "some\nmultiline\nmessage", strings.Join(tm.rows[:3], "\n"))
 		assert.Contains(t, tm.rows[3], "t=")
 		assert.Contains(t, tm.rows[3], fmt.Sprintf(" l=%s", slog.LevelDebug.String()))
-		assert.Contains(t, tm.rows[3], " s=testing_test.go:34")
+		assert.Contains(t, tm.rows[3], " s=thandler_test.go:34")
 		assert.Contains(t, tm.rows[3], `msg="message with newlines has been printed to t.Log"`)
 	})
 }

slogx.go

@@ -3,7 +3,6 @@ package slogx
 
 import (
 	"context"
-
 	"log/slog"
 )
 
@@ -49,6 +48,16 @@ func Error(err error) slog.Attr {
 	return slog.Any(ErrorKey, err)
 }
 
+// Attrs returns attributes from the given record.
+func Attrs(rec slog.Record) []slog.Attr {
+	var attrs []slog.Attr
+	rec.Attrs(func(attr slog.Attr) bool {
+		attrs = append(attrs, attr)
+		return true
+	})
+	return attrs
+}
+
 // NopHandler returns a slog.Handler, that does nothing.
 func NopHandler() slog.Handler { return nopHandler{} }
 

slogx_test.go

@@ -39,3 +39,24 @@ func TestError(t *testing.T) {
 		})
 	})
 }
+
+func TestAttrs(t *testing.T) {
+	t.Run("empty", func(t *testing.T) {
+		rec := slog.Record{}
+		attrs := Attrs(rec)
+		assert.Empty(t, attrs)
+	})
+
+	t.Run("non-empty", func(t *testing.T) {
+		rec := slog.Record{}
+		rec.AddAttrs(
+			slog.String("a", "1"),
+			slog.String("b", "2"),
+		)
+		attrs := Attrs(rec)
+		assert.Equal(t, []slog.Attr{
+			slog.String("a", "1"),
+			slog.String("b", "2"),
+		}, attrs)
+	})
+}