bubbletea/renderer_park_test.go
Viktor Danov e4d617e7e0
perf(renderer): stop the frame ticker while nothing changes (#1832)
Co-authored-by: Drew Smirnoff <drew@charm.land>
Signed-off-by: Drew Smirnoff <drew@charm.land>
2026-11-09 14:55:22 +04:00

269 lines
5.9 KiB
Go

package tea
import (
"bytes"
"context"
"io"
"strings"
"sync"
"testing"
"time"
"github.com/charmbracelet/x/ansi"
)
// These tests cover the renderer stopping its ticker while nothing changes.
// Once the ticker is stopped, a change only reaches the output if whatever
// made it woke the renderer, so each test parks the renderer first and then
// checks that the change is drawn.
// safeBuffer is an output that can be read while the program writes to it.
type safeBuffer struct {
mu sync.Mutex
buf bytes.Buffer
}
func (b *safeBuffer) Write(p []byte) (int, error) {
b.mu.Lock()
defer b.mu.Unlock()
return b.buf.Write(p) //nolint:wrapcheck
}
func (b *safeBuffer) Len() int {
b.mu.Lock()
defer b.mu.Unlock()
return b.buf.Len()
}
// since returns everything written after the first n bytes.
func (b *safeBuffer) since(n int) string {
b.mu.Lock()
defer b.mu.Unlock()
return b.buf.String()[n:]
}
// tickRenderer records when the renderer goroutine flushes, which happens
// once per tick of the frame ticker.
type tickRenderer struct {
renderer
mu sync.Mutex
ticks int
}
func (r *tickRenderer) flush(closing bool) (bool, error) {
if !closing {
r.mu.Lock()
r.ticks++
r.mu.Unlock()
}
return r.renderer.flush(closing)
}
// count returns the number of ticks so far.
func (r *tickRenderer) count() int {
r.mu.Lock()
defer r.mu.Unlock()
return r.ticks
}
type setViewMsg func(*View)
type runCmdMsg struct{ cmd Cmd }
type parkModel struct{ view View }
func (m *parkModel) Init() Cmd { return nil }
func (m *parkModel) Update(msg Msg) (Model, Cmd) {
switch msg := msg.(type) {
case setViewMsg:
msg(&m.view)
case runCmdMsg:
return m, msg.cmd
}
return m, nil
}
func (m *parkModel) View() View { return m.view }
type parkHarness struct {
t *testing.T
p *Program
out *safeBuffer
r *tickRenderer
frame time.Duration
done chan struct{}
err error // valid once done is closed
}
func newParkHarness(t *testing.T, fps int, opts ...ProgramOption) *parkHarness {
t.Helper()
ctx, cancel := context.WithTimeout(t.Context(), 30*time.Second)
t.Cleanup(cancel)
h := &parkHarness{
t: t,
out: &safeBuffer{},
frame: time.Second / time.Duration(fps),
done: make(chan struct{}),
}
h.r = &tickRenderer{renderer: newCursedRenderer(h.out, nil, 80, 24)}
opts = append([]ProgramOption{
WithContext(ctx),
WithInput(&bytes.Buffer{}),
WithOutput(h.out),
WithFPS(fps),
WithWindowSize(80, 24),
}, opts...)
h.p = NewProgram(&parkModel{view: NewView("first")}, opts...)
h.p.renderer = h.r
go func() {
defer close(h.done)
_, h.err = h.p.Run()
}()
t.Cleanup(func() {
h.p.Kill()
<-h.done
})
return h
}
// waitParked waits until the renderer has stopped ticking.
func (h *parkHarness) waitParked() {
h.t.Helper()
// Parked means no tick for well over a frame. The ticker runs for about
// half a second of unchanged frames before it stops.
quiet := 6 * h.frame
deadline := time.Now().Add(10 * time.Second)
n := h.r.count()
for time.Now().Before(deadline) {
time.Sleep(quiet)
m := h.r.count()
if m == n && n > 0 {
return
}
n = m
}
h.t.Fatal("the renderer never stopped ticking")
}
// waitOutput waits until everything in want is written after mark and
// returns how long that took.
func (h *parkHarness) waitOutput(mark int, within time.Duration, want ...string) time.Duration {
h.t.Helper()
start := time.Now()
for {
got := h.out.since(mark)
missing := ""
for _, w := range want {
if !strings.Contains(got, w) {
missing = w
break
}
}
if missing == "" {
return time.Since(start)
}
if time.Since(start) > within {
h.t.Fatalf("%q not written within %v after waking a parked renderer; got %q", missing, within, got)
}
time.Sleep(time.Millisecond)
}
}
func (h *parkHarness) setView(fn func(*View)) {
h.p.Send(setViewMsg(fn))
}
// waitDone waits for Run to return.
func (h *parkHarness) waitDone() error {
h.t.Helper()
const within = 2 * time.Second
select {
case <-h.done:
return h.err
case <-time.After(within):
h.t.Fatalf("Run did not return within %v", within)
return nil
}
}
// nopExecCommand is an ExecCommand that does nothing.
type nopExecCommand struct{}
func (nopExecCommand) Run() error { return nil }
func (nopExecCommand) SetStdin(io.Reader) {}
func (nopExecCommand) SetStdout(io.Writer) {}
func (nopExecCommand) SetStderr(io.Writer) {}
func TestRendererStopsTickingWhenIdle(t *testing.T) {
t.Parallel()
h := newParkHarness(t, 60)
h.waitOutput(0, 5*time.Second, "first")
h.waitParked()
n := h.r.count()
time.Sleep(time.Second)
if ticks := h.r.count() - n; ticks != 0 {
t.Errorf("an idle program ticked %d times in a second, want 0", ticks)
}
}
// Every way of giving the renderer work must wake it.
func TestRendererWakes(t *testing.T) {
t.Parallel()
cmd := func(c Cmd) func(h *parkHarness) {
return func(h *parkHarness) { h.p.Send(runCmdMsg{c}) }
}
tests := []struct {
name string
do func(h *parkHarness)
want []string
}{
{"content", func(h *parkHarness) { h.setView(func(v *View) { v.Content = "second" }) }, []string{"second"}},
{"Println", cmd(Println("printed")), []string{"printed"}},
{"raw", cmd(Raw("\x1b]2;raw\x07")), []string{"\x1b]2;raw\x07"}},
{"exec", cmd(Exec(nopExecCommand{}, nil)), []string{ansi.SetModeBracketedPaste, "first"}},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
h := newParkHarness(t, 60)
h.waitOutput(0, 5*time.Second, "first")
h.waitParked()
mark := h.out.Len()
tc.do(h)
took := h.waitOutput(mark, 2*time.Second, tc.want...)
t.Logf("drawn %v after waking", took)
})
}
}
func TestRendererQuitWhileParked(t *testing.T) {
t.Parallel()
h := newParkHarness(t, 60)
h.waitParked()
mark := h.out.Len()
h.setView(func(v *View) { v.Content = "last" })
h.p.Quit()
if err := h.waitDone(); err != nil {
t.Errorf("Run returned %v, want nil", err)
}
if !strings.Contains(h.out.since(mark), "last") {
t.Error("final frame not drawn")
}
}