forked from mtusi2026/mtusi2026lab2
133 lines
3.2 KiB
Go
133 lines
3.2 KiB
Go
package fiber
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"net"
|
|
"net/http"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/gofiber/fiber/v2"
|
|
)
|
|
|
|
// TestImmediateShutdown checks the startup/stop race without waiting for a first request.
|
|
func TestImmediateShutdown(t *testing.T) {
|
|
const repetitions = 10
|
|
const stopDeadline = time.Second
|
|
for range repetitions {
|
|
// Arrange.
|
|
ctrl := testController(t, nil)
|
|
// Select an ephemeral test port after validating the normal application config.
|
|
ctrl.cfg.Host = "127.0.0.1"
|
|
ctrl.cfg.Port = 0
|
|
if err := ctrl.Start(t.Context()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ctx, cancel := context.WithTimeout(t.Context(), stopDeadline)
|
|
// Act.
|
|
err := ctrl.Stop(ctx)
|
|
cancel()
|
|
// Assert.
|
|
if err != nil {
|
|
t.Fatalf("immediate shutdown leaked the listener or serve goroutine: %v", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestController_Stop_ActiveRequestDeadline bounds draining while a real handler is still running.
|
|
func TestController_Stop_ActiveRequestDeadline(t *testing.T) {
|
|
// Arrange.
|
|
const deadline = 3 * time.Second
|
|
ctrl := testController(t, nil)
|
|
ctrl.cfg.Host = "127.0.0.1"
|
|
ctrl.cfg.Port = 0
|
|
// Install one controlled handler to test lifecycle independently of business routes.
|
|
ctrl.createServer()
|
|
entered := make(chan struct{})
|
|
release := make(chan struct{})
|
|
address := make(chan string, 1)
|
|
ctrl.server.Hooks().OnListen(func(data fiber.ListenData) error {
|
|
address <- net.JoinHostPort(data.Host, data.Port)
|
|
return nil
|
|
})
|
|
ctrl.server.Get("/blocked", func(ctx *fiber.Ctx) error {
|
|
close(entered)
|
|
<-release
|
|
return ctx.SendStatus(http.StatusOK)
|
|
})
|
|
if err := ctrl.Start(t.Context()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
client := &http.Client{Timeout: deadline}
|
|
completed := make(chan error, 1)
|
|
go func() {
|
|
response, err := client.Get("http://" + <-address + "/blocked")
|
|
if err == nil {
|
|
err = response.Body.Close()
|
|
}
|
|
completed <- err
|
|
}()
|
|
t.Cleanup(func() {
|
|
close(release)
|
|
select {
|
|
case err := <-completed:
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
case <-time.After(deadline):
|
|
t.Error("blocked request did not terminate after release")
|
|
}
|
|
stopCtx, cancel := context.WithTimeout(context.Background(), deadline)
|
|
defer cancel()
|
|
if err := ctrl.Stop(stopCtx); err != nil {
|
|
t.Error(err)
|
|
}
|
|
})
|
|
select {
|
|
case <-entered:
|
|
case <-time.After(deadline):
|
|
t.Fatal("request did not reach handler")
|
|
}
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
cancel()
|
|
|
|
// Act.
|
|
err := ctrl.Stop(ctx)
|
|
|
|
// Assert.
|
|
if !errors.Is(err, context.Canceled) {
|
|
t.Fatalf("expected canceled drain, got %v", err)
|
|
}
|
|
if !ctrl.stopping.Load() {
|
|
t.Fatal("shutdown did not disable admission")
|
|
}
|
|
}
|
|
|
|
// TestCanceledStartup closes its socket while server initialization is still blocked.
|
|
func TestCanceledStartup(t *testing.T) {
|
|
// Arrange.
|
|
ctrl := testController(t, nil)
|
|
ctrl.cfg.Host = "127.0.0.1"
|
|
ctrl.cfg.Port = 0
|
|
release := make(chan struct{})
|
|
ctrl.server.Hooks().OnListen(func(_ fiber.ListenData) error {
|
|
<-release
|
|
return nil
|
|
})
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
cancel()
|
|
// Act.
|
|
err := ctrl.Start(ctx)
|
|
close(release)
|
|
// Assert.
|
|
if !errors.Is(err, context.Canceled) {
|
|
t.Fatalf("expected canceled startup, got %v", err)
|
|
}
|
|
select {
|
|
case <-ctrl.serveDone:
|
|
case <-time.After(time.Second):
|
|
t.Fatal("serving goroutine leaked after canceled startup")
|
|
}
|
|
}
|