347 lines
10 KiB
Go
347 lines
10 KiB
Go
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")
|
|
}
|
|
}
|