test: increase coverage

adapters/noop_logger_adapter.go

@@ -8,7 +8,22 @@ func NewNoOpLoggerAdapter() *NoOpLoggerAdapter {
 	return &NoOpLoggerAdapter{}
 }
 
-func (n *NoOpLoggerAdapter) Debug(message string, args ...any) {}
-func (n *NoOpLoggerAdapter) Info(message string, args ...any)  {}
-func (n *NoOpLoggerAdapter) Warn(message string, args ...any)  {}
-func (n *NoOpLoggerAdapter) Error(message string, args ...any) {}
+func (n *NoOpLoggerAdapter) Debug(message string, args ...any) {
+	// Intentionally empty - no-op implementation
+	_ = message
+}
+
+func (n *NoOpLoggerAdapter) Info(message string, args ...any) {
+	// Intentionally empty - no-op implementation
+	_ = message
+}
+
+func (n *NoOpLoggerAdapter) Warn(message string, args ...any) {
+	// Intentionally empty - no-op implementation
+	_ = message
+}
+
+func (n *NoOpLoggerAdapter) Error(message string, args ...any) {
+	// Intentionally empty - no-op implementation
+	_ = message
+}

adapters/noop_logger_adapter_test.go

@@ -0,0 +1,70 @@
+package adapters
+
+import (
+	"testing"
+)
+
+func TestNoOpLoggerAdapter(t *testing.T) {
+	logger := NewNoOpLoggerAdapter()
+
+	// Test all methods - they should not panic and do nothing
+	logger.Debug("debug message", "arg1", "arg2")
+	logger.Info("info message", "arg1", "arg2")
+	logger.Warn("warn message", "arg1", "arg2")
+	logger.Error("error message", "arg1", "arg2")
+
+	// If we reach here without panic, the test passes
+}
+
+func TestNoOpLoggerAdapter_AllMethods(t *testing.T) {
+	logger := NewNoOpLoggerAdapter()
+
+	// Call each method individually to ensure coverage
+	t.Run("Debug", func(t *testing.T) {
+		logger.Debug("test")
+	})
+
+	t.Run("Info", func(t *testing.T) {
+		logger.Info("test")
+	})
+
+	t.Run("Warn", func(t *testing.T) {
+		logger.Warn("test")
+	})
+
+	t.Run("Error", func(t *testing.T) {
+		logger.Error("test")
+	})
+}
+
+func TestNoOpLoggerAdapter_WithVariousArgs(t *testing.T) {
+	logger := NewNoOpLoggerAdapter()
+
+	// Test with no arguments
+	logger.Debug("message")
+	logger.Info("message")
+	logger.Warn("message")
+	logger.Error("message")
+
+	// Test with multiple arguments
+	logger.Debug("message %s %d", "test", 123)
+	logger.Info("message %s %d", "test", 123)
+	logger.Warn("message %s %d", "test", 123)
+	logger.Error("message %s %d", "test", 123)
+
+	// Test with nil arguments
+	logger.Debug("message", nil)
+	logger.Info("message", nil)
+	logger.Warn("message", nil)
+	logger.Error("message", nil)
+}
+
+func TestNoOpLoggerAdapter_Constructor(t *testing.T) {
+	logger := NewNoOpLoggerAdapter()
+	if logger == nil {
+		t.Fatal("expected non-nil logger")
+	}
+
+	// Verify it implements LoggerAdapter interface
+	var _ LoggerAdapter = logger
+}

adapters/print_logger_adapter_test.go

@@ -0,0 +1,59 @@
+package adapters
+
+import (
+	"testing"
+)
+
+func TestPrintLoggerAdapter(t *testing.T) {
+	t.Run("should create logger with debug level", func(t *testing.T) {
+		logger := NewPrintLoggerAdapter(LogLevelDebug)
+		if logger.level != LogLevelDebug {
+			t.Errorf("expected debug level, got %s", logger.level)
+		}
+	})
+
+	t.Run("should log debug messages when level is debug", func(t *testing.T) {
+		logger := NewPrintLoggerAdapter(LogLevelDebug)
+		logger.Debug("debug message %s", "test")
+		// If we reach here without panic, the test passes
+	})
+
+	t.Run("should log info messages when level is debug", func(t *testing.T) {
+		logger := NewPrintLoggerAdapter(LogLevelDebug)
+		logger.Info("info message %s", "test")
+		// If we reach here without panic, the test passes
+	})
+
+	t.Run("should log warn messages when level is debug", func(t *testing.T) {
+		logger := NewPrintLoggerAdapter(LogLevelDebug)
+		logger.Warn("warn message %s", "test")
+		// If we reach here without panic, the test passes
+	})
+
+	t.Run("should log error messages when level is debug", func(t *testing.T) {
+		logger := NewPrintLoggerAdapter(LogLevelDebug)
+		logger.Error("error message %s", "test")
+		// If we reach here without panic, the test passes
+	})
+
+	t.Run("should respect log levels", func(t *testing.T) {
+		// Test that higher level loggers don't log lower level messages
+		logger := NewPrintLoggerAdapter(LogLevelError)
+
+		// These should not cause any issues (they just won't output)
+		logger.Debug("debug message")
+		logger.Info("info message")
+		logger.Warn("warn message")
+		logger.Error("error message")
+	})
+
+	t.Run("should handle none level", func(t *testing.T) {
+		logger := NewPrintLoggerAdapter(LogLevelNone)
+
+		// None of these should output anything
+		logger.Debug("debug message")
+		logger.Info("info message")
+		logger.Warn("warn message")
+		logger.Error("error message")
+	})
+}