Files

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")
}
}