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