package server_test import ( "bytes" "context" "fmt" "io" "log/slog" "net" "net/http" "os" "path/filepath" "strconv" "sync" "testing" "time" "github.com/gin-gonic/gin" "messenger/internal/health" "messenger/internal/platform/config" "messenger/internal/platform/httpx" "messenger/internal/server" ) func serverDefaultConfig(t *testing.T) config.Config { t.Helper() values := make(map[string]string) for key, content := range map[string]string{ "DATABASE_URL_FILE": "postgres://unused:unused@localhost:5432/unused", "SESSION_STORE_URL_FILE": "redis://localhost:6379/0", } { path := filepath.Join(t.TempDir(), "secret") if err := os.WriteFile(path, []byte(content), 0600); err != nil { t.Fatal(err) } values[key] = path } cfg, err := config.Load(func(key string) (string, bool) { value, ok := values[key]; return value, ok }) if err != nil { t.Fatal(err) } return cfg } func TestDefaultShutdownAllowsActiveBinaryTransfers(t *testing.T) { for _, direction := range []string{"upload", "download"} { t.Run(direction, func(t *testing.T) { t.Parallel() cfg := serverDefaultConfig(t) payload := []byte("binary\x00\xff\x01request-and-response\x00\xfe") prefix := payload[:3] started, release := make(chan struct{}), make(chan struct{}) var releaseOnce sync.Once unblock := func() { releaseOnce.Do(func() { close(release) }) } bodyReader, bodyWriter := io.Pipe() ctx, cancel := context.WithCancel(context.Background()) requestCtx, cancelRequest := context.WithTimeout(context.Background(), 25*time.Second) ln, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { t.Fatal(err) } probes := health.New() handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/octet-stream") w.Header().Set("Content-Length", strconv.Itoa(len(payload))) if direction == "upload" { first := make([]byte, len(prefix)) if _, err := io.ReadFull(r.Body, first); err != nil { return } close(started) rest, err := io.ReadAll(r.Body) if err != nil || !bytes.Equal(append(first, rest...), payload) { w.WriteHeader(http.StatusBadRequest) return } _, _ = w.Write(payload) return } _, _ = w.Write(prefix) w.(http.Flusher).Flush() close(started) select { case <-release: _, _ = w.Write(payload[len(prefix):]) case <-r.Context().Done(): } }) stopped, exited := make(chan error, 1), make(chan struct{}) log := slog.New(slog.NewTextHandler(io.Discard, nil)) go func() { defer close(exited) stopped <- server.Run(ctx, log, ln, handler, probes, cfg.DrainDelay, cfg.ShutdownTimeout) }() t.Cleanup(func() { cancel() cancelRequest() unblock() _ = bodyReader.Close() _ = bodyWriter.Close() _ = ln.Close() select { case <-exited: case <-time.After(3 * time.Second): t.Error("server did not stop after transfer cleanup") } }) client := &http.Client{Transport: &http.Transport{DisableKeepAlives: true}} defer client.CloseIdleConnections() method := http.MethodGet var body io.Reader if direction == "upload" { method = http.MethodPut body = bodyReader } req, err := http.NewRequestWithContext(requestCtx, method, "http://"+ln.Addr().String()+"/binary", body) if err != nil { t.Fatal(err) } if direction == "upload" { req.ContentLength = int64(len(payload)) req.Header.Set("Content-Type", "application/octet-stream") } completed := make(chan error, 1) go func() { resp, err := client.Do(req) if err != nil { completed <- err return } defer resp.Body.Close() got, err := io.ReadAll(resp.Body) if err == nil && (resp.StatusCode != http.StatusOK || !bytes.Equal(got, payload)) { err = fmt.Errorf("binary response status=%d body=%q, want exact payload", resp.StatusCode, got) } completed <- err }() if direction == "upload" { if _, err := bodyWriter.Write(prefix); err != nil { t.Fatal(err) } } select { case <-started: case err := <-completed: t.Fatalf("transfer failed before shutdown: %v", err) case <-requestCtx.Done(): t.Fatal("transfer never became active") } cancel() // Nine seconds inside Shutdown exceeds the former 8s budget. Include // the configured drain phase so it cannot hide a premature force-close. timer := time.NewTimer(cfg.DrainDelay + 9*time.Second) defer timer.Stop() select { case err := <-stopped: t.Fatalf("shutdown interrupted active %s before binary transfer completed: %v", direction, err) case err := <-completed: t.Fatalf("active %s ended before remaining bytes were released: %v", direction, err) case <-timer.C: } if direction == "upload" { if _, err := bodyWriter.Write(payload[len(prefix):]); err != nil { t.Fatal(err) } if err := bodyWriter.Close(); err != nil { t.Fatal(err) } } else { unblock() } select { case err := <-completed: if err != nil { t.Fatalf("active %s was truncated during shutdown: %v", direction, err) } case <-requestCtx.Done(): t.Fatal("binary transfer did not finish after release") } select { case err := <-stopped: if err != nil { t.Fatalf("graceful shutdown: %v", err) } case <-requestCtx.Done(): t.Fatal("server did not finish graceful shutdown") } if probes.IsReady() { t.Fatal("readiness remained enabled after shutdown") } }) } } // newHandler builds the smallest handler with probes; the lifecycle does not // depend on the business modules or their stores. func newHandler(log *slog.Logger) (*gin.Engine, *health.Handler) { e := httpx.NewEngine(log, 1024, "test") probes := health.New() probes.Register(e) return e, probes } func TestServesUntilContextCancelledThenStopsCleanly(t *testing.T) { log := slog.New(slog.NewTextHandler(io.Discard, nil)) h, probes := newHandler(log) ln, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { t.Fatal(err) } ctx, cancel := context.WithCancel(context.Background()) done := make(chan error, 1) go func() { done <- server.Run(ctx, log, ln, h, probes, 0, 5*time.Second) }() base := "http://" + ln.Addr().String() waitFor(t, base+"/health/ready", http.StatusOK) cancel() select { case err := <-done: if err != nil { t.Fatalf("Run returned error: %v", err) } case <-time.After(10 * time.Second): t.Fatal("Run did not stop within 10s after cancel") } if _, err := http.Get(base + "/health/live"); err == nil { t.Fatal("listener must be closed after shutdown") } } func TestReadinessDropsBeforeListenerCloses(t *testing.T) { log := slog.New(slog.NewTextHandler(io.Discard, nil)) h, probes := newHandler(log) ln, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { t.Fatal(err) } ctx, cancel := context.WithCancel(context.Background()) done := make(chan error, 1) go func() { done <- server.Run(ctx, log, ln, h, probes, 0, 5*time.Second) }() base := "http://" + ln.Addr().String() waitFor(t, base+"/health/ready", http.StatusOK) // Hold one request open so shutdown has something to drain. slow := make(chan struct{}) go func() { resp, err := http.Get(base + "/health/live") if err == nil { resp.Body.Close() } close(slow) }() cancel() <-done <-slow if !probes.IsReady() { return } t.Fatal("readiness must be switched off during shutdown") } // During the drain delay the balancer is still learning that the replica is // going away: readiness already fails, yet new connections are accepted and // served. Only after the delay does the listener close. func TestDrainKeepsServingWhileNotReady(t *testing.T) { log := slog.New(slog.NewTextHandler(io.Discard, nil)) h, probes := newHandler(log) ln, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { t.Fatal(err) } ctx, cancel := context.WithCancel(context.Background()) done := make(chan error, 1) const drain = 700 * time.Millisecond go func() { done <- server.Run(ctx, log, ln, h, probes, drain, 5*time.Second) }() base := "http://" + ln.Addr().String() waitFor(t, base+"/health/ready", http.StatusOK) cancel() waitFor(t, base+"/health/ready", http.StatusServiceUnavailable) // A fresh connection, as the balancer opens for a new request. fresh := &http.Client{Transport: &http.Transport{DisableKeepAlives: true}} resp, err := fresh.Get(base + "/health/live") if err != nil { t.Fatalf("new connection during the drain delay: %v", err) } resp.Body.Close() if resp.StatusCode != http.StatusOK { t.Fatalf("liveness during drain = %d, want 200", resp.StatusCode) } select { case err := <-done: if err != nil { t.Fatalf("Run returned error: %v", err) } case <-time.After(10 * time.Second): t.Fatal("Run did not stop after the drain delay") } if _, err := fresh.Get(base + "/health/live"); err == nil { t.Fatal("listener must be closed after the drain delay") } } func waitFor(t *testing.T, url string, status int) { t.Helper() deadline := time.Now().Add(5 * time.Second) for time.Now().Before(deadline) { resp, err := http.Get(url) if err == nil { resp.Body.Close() if resp.StatusCode == status { return } } time.Sleep(20 * time.Millisecond) } t.Fatalf("%s did not return %d in time", url, status) } // The debug listener has no drain: it serves the benchmark's metrics scraper // only and stops with the process. func TestRunDebugServesUntilCancelled(t *testing.T) { log := slog.New(slog.NewTextHandler(io.Discard, nil)) ln, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { t.Fatal(err) } h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { w.WriteHeader(http.StatusTeapot) }) ctx, cancel := context.WithCancel(context.Background()) done := make(chan error, 1) go func() { done <- server.RunDebug(ctx, log, ln, h) }() waitFor(t, "http://"+ln.Addr().String()+"/debug/vars", http.StatusTeapot) cancel() select { case err := <-done: if err != nil { t.Fatalf("RunDebug returned %v", err) } case <-time.After(2 * time.Second): t.Fatal("RunDebug did not stop after cancel") } }