Files
summercms/modules/surf/close_test.go
Jakub Zych d9e21ad019 fix(surf): close the rate-limit store a router created (quick-261118-lbt)
- MemoryStore.Close stops the sweep goroutine; Attempt keeps working
- Router.Close runs what the router owns (the fallback MemoryStore of
  BuildRouter), never a store published on the app
- BuildRouter closes the router on every error return
- serve closes its router and installCooler's fallback store on exit;
  route:list closes its router
- README and rate-limiting docs describe the ownership
2026-11-18 15:41:05 +01:00

150 lines
4.0 KiB
Go

package surf
import (
"runtime"
"testing"
"time"
)
// waitClosed reports whether ch closes within d.
func waitClosed(ch <-chan struct{}, d time.Duration) bool {
select {
case <-ch:
return true
case <-time.After(d):
return false
}
}
// waitGoroutines polls until runtime.NumGoroutine is at most limit or d
// passes, and returns the last count.
func waitGoroutines(limit int, d time.Duration) int {
deadline := time.Now().Add(d)
n := runtime.NumGoroutine()
for n > limit && time.Now().Before(deadline) {
time.Sleep(10 * time.Millisecond)
n = runtime.NumGoroutine()
}
return n
}
func routerStore(t *testing.T, r *Router) *MemoryStore {
t.Helper()
if r == nil || r.limiter == nil {
t.Fatal("router has no limiter")
}
ms, ok := r.limiter.store.(*MemoryStore)
if !ok {
t.Fatalf("limiter store = %T, want *MemoryStore", r.limiter.store)
}
return ms
}
func TestMemoryStoreClose(t *testing.T) {
s := NewMemoryStore(time.Millisecond)
if err := s.Close(); err != nil {
t.Fatalf("Close: %v", err)
}
if !waitClosed(s.done, 2*time.Second) {
t.Fatal("sweep loop still running after Close")
}
if err := s.Close(); err != nil {
t.Fatalf("second Close: %v", err)
}
if err := (*MemoryStore)(nil).Close(); err != nil {
t.Fatalf("nil Close: %v", err)
}
if err := NewMemoryStore(0).Close(); err != nil {
t.Fatalf("no-sweep Close: %v", err)
}
if err := (&MemoryStore{}).Close(); err != nil {
t.Fatalf("zero-value Close: %v", err)
}
if ok, n, _ := s.Attempt("k", 2, time.Minute); !ok || n != 1 {
t.Fatalf("Attempt after Close = %v %d, want true 1", ok, n)
}
if ok, n, _ := s.Attempt("k", 2, time.Minute); !ok || n != 2 {
t.Fatalf("second Attempt after Close = %v %d, want true 2", ok, n)
}
if ok, _, _ := s.Attempt("k", 2, time.Minute); ok {
t.Fatal("third Attempt after Close admitted past max")
}
}
func TestRouterCloseOwnedStore(t *testing.T) {
for name, build := range map[string]func() (*Router, error){
"nil app": func() (*Router, error) { return BuildRouter(nil, nil) },
"config app": func() (*Router, error) {
return BuildRouter(transportApp(t, "development", map[string]string{"http.yaml": transportBodyLimits}), nil)
},
} {
t.Run(name, func(t *testing.T) {
r, err := build()
if err != nil {
t.Fatal(err)
}
ms := routerStore(t, r)
if err := r.Close(); err != nil {
t.Fatalf("Close: %v", err)
}
if !waitClosed(ms.done, 2*time.Second) {
t.Fatal("fallback store still sweeping after Router.Close")
}
if err := r.Close(); err != nil {
t.Fatalf("second Close: %v", err)
}
})
}
if err := (*Router)(nil).Close(); err != nil {
t.Fatalf("nil router Close: %v", err)
}
if err := New(nil).Close(); err != nil {
t.Fatalf("New(nil).Close: %v", err)
}
}
func TestRouterCloseKeepsPublishedStore(t *testing.T) {
app := transportApp(t, "development", map[string]string{"http.yaml": transportBodyLimits})
published := NewMemoryStore(time.Millisecond)
t.Cleanup(func() { _ = published.Close() })
if err := app.Publish[Store](published); err != nil {
t.Fatal(err)
}
r, err := BuildRouter(app, nil)
if err != nil {
t.Fatal(err)
}
if got := routerStore(t, r); got != published {
t.Fatal("BuildRouter did not use the published store")
}
if err := r.Close(); err != nil {
t.Fatalf("Close: %v", err)
}
if waitClosed(published.done, 50*time.Millisecond) {
t.Fatal("Router.Close closed a store published on the app")
}
}
func TestRouterCloseReleasesGoroutines(t *testing.T) {
baseline := runtime.NumGoroutine()
routers := make([]*Router, 0, 20)
for range 20 {
r, err := BuildRouter(nil, nil)
if err != nil {
t.Fatal(err)
}
routers = append(routers, r)
}
if n := runtime.NumGoroutine(); n < baseline+20 {
t.Fatalf("20 routers raised goroutines from %d to %d, want at least +20", baseline, n)
}
for _, r := range routers {
if err := r.Close(); err != nil {
t.Fatal(err)
}
}
if n := waitGoroutines(baseline+2, 2*time.Second); n > baseline+2 {
t.Fatalf("goroutines = %d after closing 20 routers, want at most %d", n, baseline+2)
}
}