yonluandClaude Opus 5
4471db3aef
Phases 2 and 3 of plan 009, plus the parts of phase 1 that could not
land before them. Nothing in the tree imports wails/v2 any more; all
three lint and test configurations are green and `go build .` produces
a running binary.
The point of the migration is one file. backend/events/emit.go probed
ctx.Value("events") — a v2-*private* context key — to decide whether
emitting was safe, because runtime.EventsEmit called log.Fatalf on a
context without the runtime and took the process down with it. v3's
emit takes no context, so that is now application.Get() == nil. D1
held: events.Emit keeps its ctx as the WithSink test seam, and all 45
call sites and 7 test files are untouched.
The bootstrap splits into application.New + Window.NewWithOptions +
Run. Ten bound services implement ServiceStartup instead of being
handed a context by hand from OnStartup, which also stops ten
SetContext methods being exported as bindings. jobs.Registry and
explore.SearchIndex keep theirs — neither is bound, so converting them
would be churn for no binding removed.
Four things differed from the plan and are written up in it: GPU policy
moved to the per-window LinuxWindow options rather than surviving on
LinuxOptions; there is no OnStartup/OnDomReady option, so app-level
wiring hangs off ApplicationStarted; application.NewService is generic,
so FEBindings []any could not survive (the binding generator is a
static analyser and would have seen nothing); and the quit veto had to
be restructured, because v3's dialog answers on a callback rather than
returning the button, so ShouldQuit vetoes, asks, and quits again from
the callback.
Window state saving moves to a WindowClosing hook — the size has to be
read while the window still exists, and v3's OnShutdown has neither
context nor window. backend/logging is deleted rather than ported:
v3 takes a *slog.Logger directly, so the v2 logger.Logger adapter had
no caller left.
Phase 1's tail rides along, now that it can: the Makefile's wails
invocations, all 50 webkit2_41 sites, lefthook, both packaging recipes
and ci.yml's apt lists. v3 builds against GTK4 + WebKitGTK 6.0, which
Arch and ubuntu:24.04 both ship, so the tag is a deletion rather than
a translation.
Phase 4 is next and the branch is not usable until it lands: the app
builds, but frontend/wailsjs/ is v2's tree and nothing regenerates it,
so the frontend cannot reach the backend yet.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UDCbcCZQepnpSQYJ6SxxZm
88 lines
2.2 KiB
Go
88 lines
2.2 KiB
Go
package player
|
|
|
|
import (
|
|
"context"
|
|
"log/slog"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/wailsapp/wails/v3/pkg/application"
|
|
|
|
"yellowjacket/backend/events"
|
|
)
|
|
|
|
// recordedPlayer is a player with an event sink installed and no audio
|
|
// device: enough to assert on what the frontend would receive from the
|
|
// paths that do not touch the speaker.
|
|
func recordedPlayer(t *testing.T) (*Player, *events.Recorder) {
|
|
t.Helper()
|
|
|
|
p := NewPlayer(slog.Default(), nil)
|
|
rec := events.NewRecorder()
|
|
_ = p.ServiceStartup(events.WithSink(t.Context(), rec), application.ServiceOptions{})
|
|
|
|
return p, rec
|
|
}
|
|
|
|
func TestSeek_WithNoTrackEmitsSeekFailed(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
p, rec := recordedPlayer(t)
|
|
|
|
if err := p.Seek(5); err == nil {
|
|
t.Fatal("Seek with no track loaded returned nil error")
|
|
}
|
|
|
|
// C2: the frontend has made an optimistic move it now has to take
|
|
// back, and this is the only thing that tells it so.
|
|
if _, ok := rec.Last(events.SeekFailed); !ok {
|
|
t.Errorf("no SeekFailed emitted; got %v", rec.Names())
|
|
}
|
|
}
|
|
|
|
func TestPositionTicker_SilentWhileNotPlaying(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
_, rec := recordedPlayer(t)
|
|
|
|
// The ticker is running (SetContext started it) but nothing is
|
|
// playing, so a paused app must not push a position a second
|
|
// forever.
|
|
time.Sleep(positionTickInterval * 2)
|
|
|
|
if got := rec.Count(events.PlaybackPositionChanged); got != 0 {
|
|
t.Errorf("position emitted %d times while stopped, want 0", got)
|
|
}
|
|
}
|
|
|
|
func TestEmitPosition_CarriesLengthAndSequence(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
p := NewPlayer(slog.Default(), nil)
|
|
rec := events.NewRecorder()
|
|
p.ctx = events.WithSink(context.Background(), rec)
|
|
|
|
p.mu.Lock()
|
|
p.emitPositionLocked()
|
|
p.emitPositionLocked()
|
|
p.mu.Unlock()
|
|
|
|
ticks := rec.Named(events.PlaybackPositionChanged)
|
|
if len(ticks) != 2 {
|
|
t.Fatalf("emitted %d positions, want 2", len(ticks))
|
|
}
|
|
|
|
first, ok := ticks[0].Payload().(PositionInfo)
|
|
if !ok {
|
|
t.Fatalf("payload is %T, want player.PositionInfo", ticks[0].Payload())
|
|
}
|
|
|
|
second, _ := ticks[1].Payload().(PositionInfo)
|
|
|
|
// The sequence is what lets the seek bar reset its interpolation
|
|
// on a tick that reports the same second twice.
|
|
if second.Seq <= first.Seq {
|
|
t.Errorf("seq did not advance: %d then %d", first.Seq, second.Seq)
|
|
}
|
|
}
|