- 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
150 lines
4.0 KiB
Go
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)
|
|
}
|
|
}
|