1 files changed, 91 insertions, 0 deletions
diff --git a/internal/cli/serve_test.go b/internal/cli/serve_test.go
new file mode 100644
index 0000000..6bd0e8f
--- /dev/null
+++ b/internal/cli/serve_test.go
@@ -0,0 +1,91 @@
+package cli
+
+import (
+	"context"
+	"log/slog"
+	"net"
+	"net/http"
+	"sync"
+	"testing"
+	"time"
+)
+
+// recordHandler captures log records for assertions.
+type recordHandler struct {
+	mu      sync.Mutex
+	records []slog.Record
+}
+
+func (h *recordHandler) Enabled(_ context.Context, _ slog.Level) bool { return true }
+func (h *recordHandler) Handle(_ context.Context, r slog.Record) error {
+	h.mu.Lock()
+	h.records = append(h.records, r)
+	h.mu.Unlock()
+	return nil
+}
+func (h *recordHandler) WithAttrs(_ []slog.Attr) slog.Handler  { return h }
+func (h *recordHandler) WithGroup(_ string) slog.Handler       { return h }
+func (h *recordHandler) hasWarn(msg string) bool {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	for _, r := range h.records {
+		if r.Level == slog.LevelWarn && r.Message == msg {
+			return true
+		}
+	}
+	return false
+}
+
+// TestServe_ShutdownError_IsLogged verifies that a shutdown timeout error is
+// logged as a warning rather than silently dropped.
+func TestServe_ShutdownError_IsLogged(t *testing.T) {
+	// Start a real listener so we have an address.
+	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("listen: %v", err)
+	}
+
+	// Handler that hangs so the active connection prevents clean shutdown.
+	hang := make(chan struct{})
+	mux := http.NewServeMux()
+	mux.HandleFunc("/hang", func(w http.ResponseWriter, r *http.Request) {
+		<-hang
+	})
+
+	srv := &http.Server{Handler: mux}
+
+	// Serve in background.
+	go srv.Serve(ln) //nolint:errcheck
+
+	// Open a connection and start a hanging request so the server has an
+	// active connection when we call Shutdown.
+	addr := ln.Addr().String()
+	connReady := make(chan struct{})
+	go func() {
+		req, _ := http.NewRequest(http.MethodGet, "http://"+addr+"/hang", nil)
+		close(connReady)
+		http.DefaultClient.Do(req) //nolint:errcheck
+	}()
+	<-connReady
+	// Give the goroutine a moment to establish the request.
+	time.Sleep(20 * time.Millisecond)
+
+	// Shutdown with an already-expired deadline so it times out immediately.
+	expiredCtx, cancel := context.WithDeadline(context.Background(), time.Now().Add(-1*time.Second))
+	defer cancel()
+
+	h := &recordHandler{}
+	logger := slog.New(h)
+
+	// This is the exact logic from serve.go's shutdown goroutine.
+	if err := srv.Shutdown(expiredCtx); err != nil {
+		logger.Warn("shutdown error", "err", err)
+	}
+
+	// Unblock the hanging handler.
+	close(hang)
+
+	if !h.hasWarn("shutdown error") {
+		t.Error("expected shutdown error to be logged as Warn, but it was not")
+	}
+}