add more tests, add examples, fix bug in handle when withValue hasnt been called yet

Author: Felttrip

context_test.go

@@ -18,19 +18,16 @@ func TestWithValue(t *testing.T) {
 		defer ctx.Done()
 
 		ctx = WithValue(ctx, "key1", "value1")
-		val := ctx.Value(ctxKey("key1"))
-		//we expect value1 to end up in the context
-		if val != "value1" {
-			t.Errorf("Expected value1, got %v", val)
+		m, ok := ctx.Value(fieldsKey).(*safeMap)
+		if !ok {
+			t.Errorf("Expected safeMap to be initialized in context")
 		}
-
-		loggedFields.mu.Lock()
-		//we expect the key to be in the loggedFields
-		if loggedFields.fields[0] != "key1" {
-			t.Errorf("Expected key1, got %v", loggedFields.fields[0])
+		//we expect value1 to end up in the contexts map
+		m.mu.Lock()
+		if m.fields["key1"] != "value1" {
+			t.Errorf("Expected value1, got %v", m.fields["key1"])
 		}
-		loggedFields.mu.Unlock()
-		ctx.Done()
+		m.mu.Unlock()
 	})
 
 	t.Run("Will Store Multiple Values On Context", func(t *testing.T) {
@@ -40,15 +37,19 @@ func TestWithValue(t *testing.T) {
 		ctx = WithValue(ctx, "key2", "value2")
 		ctx = WithValue(ctx, "key3", "value3")
 
-		// we expect value2 and value3 to end up in the context
-		val := ctx.Value(ctxKey("key2"))
-		if val != "value2" {
-			t.Errorf("Expected value2, got %v", val)
+		m, ok := ctx.Value(fieldsKey).(*safeMap)
+		if !ok {
+			t.Errorf("Expected safeMap to be initialized in context")
+		}
+		//we expect value2 and value3 to end up in the contexts map
+		m.mu.Lock()
+		if m.fields["key2"] != "value2" {
+			t.Errorf("Expected value2, got %v", m.fields["key2"])
 		}
-		val = ctx.Value(ctxKey("key3"))
-		if val != "value3" {
-			t.Errorf("Expected value3, got %v", val)
+		if m.fields["key3"] != "value3" {
+			t.Errorf("Expected value3, got %v", m.fields["key3"])
 		}
+		m.mu.Unlock()
 	})
 
 	t.Run("Will panic with nil parent", func(t *testing.T) {
@@ -60,7 +61,6 @@ func TestWithValue(t *testing.T) {
 }
 
 func TestWithValues(t *testing.T) {
-
 	t.Run("Will Store Multiple Values On Context", func(t *testing.T) {
 		ctx := context.Background()
 		defer ctx.Done()
@@ -76,16 +76,19 @@ func TestWithValues(t *testing.T) {
 			"complexData": cd,
 		})
 
-		// we expect all the fields to end up in the context
-		val := ctx.Value(ctxKey("AccountID"))
-		if val != 987654321 {
-			t.Errorf("Expected 987654321, got %v", val)
+		m, ok := ctx.Value(fieldsKey).(*safeMap)
+		if !ok {
+			t.Errorf("Expected safeMap to be initialized in context")
+		}
+		//we expect value1 to end up in the contexts map
+		m.mu.Lock()
+		if m.fields["AccountID"] != 987654321 {
+			t.Errorf("Expected 987654321, got %v", m.fields["AccountID"])
 		}
-		val = ctx.Value(ctxKey("email"))
-		if val != "[email protected]" {
-			t.Errorf("Expected [email protected], got %v", val)
+		if m.fields["email"] != "[email protected]" {
+			t.Errorf("Expected [email protected], got %v", m.fields["email"])
 		}
-		complexVal, ok := ctx.Value(ctxKey("complexData")).(ComplexData)
+		complexVal, ok := m.fields["complexData"].(ComplexData)
 		if !ok {
 			t.Errorf("mistatch type when retrieving ComplexData from context")
 		}
@@ -101,6 +104,7 @@ func TestWithValues(t *testing.T) {
 		if complexVal.SliceField[0] != "one" || complexVal.SliceField[1] != "two" || complexVal.SliceField[2] != "three" {
 			t.Errorf("Expected []string{\"one\", \"two\", \"three\"}, got %v", complexVal.SliceField)
 		}
+		m.mu.Unlock()
 	})
 
 	t.Run("Will panic with nil parent", func(t *testing.T) {

handler.go

@@ -24,7 +24,7 @@ func (h Handler) Enabled(ctx context.Context, lvl slog.Level) bool {
 
 // Handle implements slog.Handler.
 func (h Handler) Handle(ctx context.Context, r slog.Record) error {
-	if sm := ctx.Value(fieldsKey).(*safeMap); sm != nil {
+	if sm, ok := ctx.Value(fieldsKey).(*safeMap); ok {
 		sm.mu.Lock()
 		for k, v := range sm.fields {
 			r.AddAttrs(slog.Any(string(k), v))

handler_test.go

@@ -0,0 +1,212 @@
+package ctxslog_test
+
+import (
+	"context"
+	"log/slog"
+	"os"
+	"testing"
+
+	"github.com/felttrip/ctxslog"
+)
+
+func TestNewHandler(t *testing.T) {
+	mockHandler := &MockHandler{}
+	handler := ctxslog.NewHandler(mockHandler)
+
+	if handler == nil {
+		t.Error("NewHandler returned nil")
+	}
+}
+
+func TestHandlerEnabled(t *testing.T) {
+	mockHandler := &MockHandler{}
+	handler := ctxslog.NewHandler(mockHandler)
+
+	ctx := context.Background()
+
+	// Test with different log levels should just default down to the mock handler which is true for all
+	levels := []slog.Level{slog.LevelDebug, slog.LevelInfo, slog.LevelWarn, slog.LevelError}
+	for _, level := range levels {
+		enabled := handler.Enabled(ctx, level)
+		if !enabled {
+			t.Errorf("Handler.Enabled returned false for level %s", level)
+		}
+	}
+}
+
+func TestHandlerHandle(t *testing.T) {
+	t.Run("Will Handle when nothing has been added to context", func(t *testing.T) {
+		mockHandler := &MockHandler{}
+		handler := ctxslog.NewHandler(mockHandler)
+
+		ctx := context.Background()
+		record := slog.Record{
+			Level:   slog.LevelInfo,
+			Message: "Test message",
+		}
+
+		err := handler.Handle(ctx, record)
+		if err != nil {
+			t.Errorf("Handler.Handle returned an error: %v", err)
+		}
+
+		if !mockHandler.HandleCalled {
+			t.Error("MockHandler.Handle was not called")
+		}
+
+		if mockHandler.HandleRecord.Message != record.Message || mockHandler.HandleRecord.Level != record.Level {
+			t.Error("MockHandler.Handle did not receive the correct record")
+		}
+	})
+	t.Run("Will Handle when values have been added to context and add them to attrs", func(t *testing.T) {
+		mockHandler := &MockHandler{}
+		handler := ctxslog.NewHandler(mockHandler)
+
+		ctx := context.Background()
+		ctx = ctxslog.WithValue(ctx, "key1", "value1")
+		ctx = ctxslog.WithValue(ctx, "key2", "value2")
+
+		expectedAttrs := []slog.Attr{
+			{Key: "key1", Value: slog.StringValue("value1")},
+			{Key: "key2", Value: slog.StringValue("value2")},
+		}
+		record := slog.Record{
+			Level:   slog.LevelInfo,
+			Message: "Test message",
+		}
+
+		err := handler.Handle(ctx, record)
+		if err != nil {
+			t.Errorf("Handler.Handle returned an error: %v", err)
+		}
+
+		if !mockHandler.HandleCalled {
+			t.Error("MockHandler.Handle was not called")
+		}
+
+		if mockHandler.HandleRecord.Message != record.Message || mockHandler.HandleRecord.Level != record.Level {
+			t.Error("MockHandler.Handle did not receive the correct record")
+		}
+
+		if mockHandler.HandleRecord.NumAttrs() != len(expectedAttrs) {
+			t.Error("MockHandler.WithAttrs did not receive the correct number of attributes")
+		}
+	})
+}
+
+type ComplexData struct {
+	IntField   int
+	StrField   string
+	BoolField  bool
+	SliceField []string
+}
+
+func ExampleHandler() {
+	slog.SetDefault(slog.New(ctxslog.NewHandler(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
+		ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
+			// Remove time from the output for predictable test output.
+			if a.Key == slog.TimeKey {
+				return slog.Attr{}
+			}
+			return a
+		},
+	}))))
+
+	ctx := ctxslog.WithValue(context.Background(), "AccountID", 123456789)
+	ctx = ctxslog.WithValue(ctx, "email", "[email protected]")
+	ctx = ctxslog.WithValue(ctx, "sender", "[email protected]")
+
+	slog.InfoContext(ctx, "Info With Context")
+	ctx = ctxslog.WithValues(context.Background(), map[string]interface{}{
+		"AccountID": 987654321,
+		"email":     "[email protected]",
+		"complexData": ComplexData{
+			IntField:   123,
+			StrField:   "DEADBEEF",
+			BoolField:  true,
+			SliceField: []string{"one", "two", "three"},
+		},
+	})
+
+	slog.ErrorContext(ctx, "Error With Context")
+	// Output:
+	//{"level":"INFO","msg":"Info With Context","AccountID":123456789,"email":"[email protected]","sender":"[email protected]"}
+	//{"level":"ERROR","msg":"Error With Context","AccountID":987654321,"email":"[email protected]","complexData":{"IntField":123,"StrField":"DEADBEEF","BoolField":true,"SliceField":["one","two","three"]}}
+
+}
+
+func TestHandlerWithAttrs(t *testing.T) {
+	mockHandler := &MockHandler{}
+	handler := ctxslog.NewHandler(mockHandler)
+
+	attrs := []slog.Attr{
+		{Key: "attr1", Value: slog.StringValue("value1")},
+		{Key: "attr2", Value: slog.StringValue("value2")},
+	}
+
+	newHandler := handler.WithAttrs(attrs)
+
+	if newHandler == nil {
+		t.Error("Handler.WithAttrs returned nil")
+	}
+
+	if len(mockHandler.WithAttrsAttrs) != len(attrs) {
+		t.Error("MockHandler.WithAttrs did not receive the correct number of attributes")
+	}
+
+	for i, attr := range attrs {
+		if !mockHandler.WithAttrsAttrs[i].Equal(attr) {
+			t.Errorf("MockHandler.WithAttrs did not receive the correct attribute at index %d", i)
+		}
+	}
+}
+
+func TestHandlerWithGroup(t *testing.T) {
+	mockHandler := &MockHandler{WithGroupCalled: false}
+	handler := ctxslog.NewHandler(mockHandler)
+	groupName := "test-group"
+
+	newHandler := handler.WithGroup(groupName)
+
+	if newHandler == nil {
+		t.Error("Handler.WithGroup returned nil")
+	}
+
+	if mockHandler.WithGroupCalled != true {
+		t.Error("MockHandler.WithGroup was not called")
+	}
+
+	if mockHandler.WithGroupName != groupName {
+		t.Error("MockHandler.WithGroup did not receive the correct group name")
+	}
+}
+
+// MockHandler is a mock implementation of slog.Handler for testing purposes.
+type MockHandler struct {
+	HandleCalled    bool
+	HandleRecord    slog.Record
+	WithAttrsAttrs  []slog.Attr
+	WithGroupCalled bool
+	WithGroupName   string
+}
+
+func (m *MockHandler) Enabled(ctx context.Context, lvl slog.Level) bool {
+	return true
+}
+
+func (m *MockHandler) Handle(ctx context.Context, r slog.Record) error {
+	m.HandleCalled = true
+	m.HandleRecord = r
+	return nil
+}
+
+func (m *MockHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
+	m.WithAttrsAttrs = attrs
+	return m
+}
+
+func (m *MockHandler) WithGroup(name string) slog.Handler {
+	m.WithGroupCalled = true
+	m.WithGroupName = name
+	return m
+}