sneak
2710e700e8
check / check (push) Canceled after 0s
The Enter handler of the input line and the Alt and digit key handler ran the typed line on the tview event loop. Every UI method that changes the screen waits for that loop, so the client stopped responding. Each line now runs on its own goroutine, which first waits for the line before it, so lines keep the order they were typed in. /window now runs off the event loop. It reads the buffer name through the new BufferName, which runs on the loop, instead of reading the buffer list directly. A new test drives a running UI on a simulation screen with Alt and 1, then a typed line and Enter. Model: opus-5-5
465 lines
11 KiB
Go
465 lines
11 KiB
Go
package cli
|
|
|
|
import (
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/gdamore/tcell/v2"
|
|
api "sneak.berlin/go/neoirc/internal/cli/api"
|
|
"sneak.berlin/go/neoirc/pkg/irc"
|
|
)
|
|
|
|
// The user's nick, a channel it is in, another user's nick and
|
|
// a message text, for the tests below.
|
|
const (
|
|
testNick = "erin"
|
|
testChannel = "#chan"
|
|
testOtherNick = "bob"
|
|
testText = "hello"
|
|
)
|
|
|
|
// eventLoopTimeout is how long a test waits for a typed line to
|
|
// be handled, or for the UI to stop, before it fails.
|
|
const eventLoopTimeout = 5 * time.Second
|
|
|
|
func TestMemberPrefix(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
member api.Member
|
|
want string
|
|
}{
|
|
{
|
|
name: "operator",
|
|
member: api.Member{Nick: "alice", IsOperator: true},
|
|
want: "@",
|
|
},
|
|
{
|
|
name: "voiced member",
|
|
member: api.Member{Nick: "bob", IsVoiced: true},
|
|
want: "+",
|
|
},
|
|
{
|
|
name: "voiced operator",
|
|
member: api.Member{
|
|
Nick: "Carol", IsOperator: true, IsVoiced: true,
|
|
},
|
|
want: "@",
|
|
},
|
|
{
|
|
name: "plain member",
|
|
member: api.Member{Nick: "dave"},
|
|
want: "",
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := memberPrefix(test.member)
|
|
if got != test.want {
|
|
t.Fatalf("got %q, want %q", got, test.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestPartEvent checks that a PART event adds a line to the
|
|
// channel's buffer and marks it unread, except that the
|
|
// user's own part does not mark it unread.
|
|
func TestPartEvent(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
from string
|
|
wantUnread int
|
|
}{
|
|
{name: "own part", from: testNick, wantUnread: 0},
|
|
{name: "other member", from: testOtherNick, wantUnread: 1},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
app := &App{ui: NewUI(), nick: testNick}
|
|
runUI(t, app.ui)
|
|
|
|
app.handleServerMessage(&api.Message{
|
|
Command: irc.CmdPart, From: test.from, To: testChannel,
|
|
})
|
|
|
|
lines, unread := bufferState(app.ui, testChannel)
|
|
if lines != 1 || unread != test.wantUnread {
|
|
t.Fatalf("got %d lines and %d unread, want 1 and %d",
|
|
lines, unread, test.wantUnread)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestOwnCommandShownOnce checks that a message, join or
|
|
// part made from neoirc-cli shows as one line in the
|
|
// channel's buffer once the server's event for it arrives,
|
|
// and does not mark the channel unread.
|
|
func TestOwnCommandShownOnce(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
send func(app *App)
|
|
event api.Message
|
|
}{
|
|
{
|
|
name: "message",
|
|
send: func(app *App) { app.handleInput(testText) },
|
|
event: api.Message{
|
|
Command: irc.CmdPrivmsg, From: testNick, To: testChannel,
|
|
Body: []string{testText},
|
|
},
|
|
},
|
|
{
|
|
name: "join",
|
|
send: func(app *App) { app.cmdJoin(testChannel) },
|
|
event: api.Message{
|
|
Command: irc.CmdJoin, From: testNick, To: testChannel,
|
|
},
|
|
},
|
|
{
|
|
name: "part",
|
|
send: func(app *App) { app.cmdPart(testChannel) },
|
|
event: api.Message{
|
|
Command: irc.CmdPart, From: testNick, To: testChannel,
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// The server accepts every command. Only the response
|
|
// to a JOIN is read, and it says the session joined.
|
|
server := newServer(t, `{"status": "joined"}`)
|
|
|
|
app := &App{
|
|
ui: NewUI(),
|
|
client: api.NewClient(server.URL),
|
|
nick: testNick,
|
|
target: testChannel,
|
|
connected: true,
|
|
}
|
|
runUI(t, app.ui)
|
|
app.ui.SwitchToBuffer(testChannel)
|
|
|
|
test.send(app)
|
|
app.handleServerMessage(&test.event)
|
|
|
|
lines, unread := bufferState(app.ui, testChannel)
|
|
if lines != 1 || unread != 0 {
|
|
t.Fatalf("got %d lines and %d unread, want 1 and 0",
|
|
lines, unread)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestJoinResponse checks that /join switches to the channel's
|
|
// buffer and makes it the target only when the server answers
|
|
// that the session joined.
|
|
func TestJoinResponse(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
response string
|
|
// The buffer shown and the target after the join.
|
|
want string
|
|
}{
|
|
{
|
|
name: "joined",
|
|
response: `{"status": "joined", "channel": "#chan"}`,
|
|
want: testChannel,
|
|
},
|
|
{
|
|
name: "refused",
|
|
response: `{"status": "error"}`,
|
|
want: testOtherNick,
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
app := &App{
|
|
ui: NewUI(),
|
|
client: api.NewClient(newServer(t, test.response).URL),
|
|
nick: testNick,
|
|
target: testOtherNick,
|
|
connected: true,
|
|
}
|
|
runUI(t, app.ui)
|
|
app.ui.SwitchToBuffer(testOtherNick)
|
|
|
|
app.cmdJoin(testChannel)
|
|
|
|
var shown string
|
|
|
|
app.ui.app.QueueUpdate(func() {
|
|
shown = app.ui.buffers[app.ui.currentBuffer].Name
|
|
})
|
|
|
|
if shown != test.want || app.target != test.want {
|
|
t.Fatalf("got buffer %s and target %s, want %s",
|
|
shown, app.target, test.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestAltDigit checks that Alt and a digit shows that window and
|
|
// makes its channel or user the target, as /window does. Window
|
|
// 0, the status window, leaves no target.
|
|
func TestAltDigit(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
digit rune
|
|
// The buffer shown and the target after the key.
|
|
wantBuffer string
|
|
wantTarget string
|
|
}{
|
|
{
|
|
name: "channel window",
|
|
digit: '1',
|
|
wantBuffer: testChannel,
|
|
wantTarget: testChannel,
|
|
},
|
|
{
|
|
name: "status window",
|
|
digit: '0',
|
|
wantBuffer: "(status)",
|
|
wantTarget: "",
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
app := &App{ui: NewUI(), nick: testNick, target: testOtherNick}
|
|
handled := handledLines(app)
|
|
runUI(t, app.ui)
|
|
|
|
// Window 1 is the channel. Window 2, the one shown, is
|
|
// the other user's.
|
|
app.ui.SwitchToBuffer(testChannel)
|
|
app.ui.SwitchToBuffer(testOtherNick)
|
|
|
|
key := tcell.NewEventKey(tcell.KeyRune, test.digit, tcell.ModAlt)
|
|
app.ui.app.QueueEvent(key)
|
|
waitHandled(t, handled, "/window "+string(test.digit))
|
|
|
|
var shown string
|
|
|
|
app.ui.app.QueueUpdate(func() {
|
|
shown = app.ui.buffers[app.ui.currentBuffer].Name
|
|
})
|
|
|
|
if shown != test.wantBuffer || app.target != test.wantTarget {
|
|
t.Fatalf("got buffer %s and target %q, want %s and %q",
|
|
shown, app.target, test.wantBuffer, test.wantTarget)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestEventLoopKeepsRunning sends Alt and 1, then a typed line and
|
|
// Enter, to a running UI. It checks that both are handled, in that
|
|
// order, so the event loop did not stop on either.
|
|
func TestEventLoopKeepsRunning(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
app := &App{ui: NewUI(), nick: testNick}
|
|
handled := handledLines(app)
|
|
runUI(t, app.ui)
|
|
|
|
// Window 1 is the channel, and window 0, the status window, is
|
|
// shown. The typed line adds a line to the status window, as
|
|
// the client is not connected.
|
|
app.ui.SwitchToBuffer(testChannel)
|
|
app.ui.SwitchBuffer(0)
|
|
|
|
app.ui.app.QueueEvent(tcell.NewEventKey(tcell.KeyRune, '1', tcell.ModAlt))
|
|
|
|
for _, r := range testText {
|
|
app.ui.app.QueueEvent(tcell.NewEventKey(tcell.KeyRune, r, tcell.ModNone))
|
|
}
|
|
|
|
app.ui.app.QueueEvent(tcell.NewEventKey(tcell.KeyEnter, 0, tcell.ModNone))
|
|
|
|
waitHandled(t, handled, "/window 1")
|
|
waitHandled(t, handled, testText)
|
|
}
|
|
|
|
// TestOwnEventFromOtherClient checks that a message, notice,
|
|
// join or part that the user's session makes from another
|
|
// client shows as one line in the buffer it belongs to.
|
|
func TestOwnEventFromOtherClient(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
event api.Message
|
|
buffer string
|
|
}{
|
|
{
|
|
name: "channel message",
|
|
event: api.Message{
|
|
Command: irc.CmdPrivmsg, From: testNick, To: testChannel,
|
|
Body: []string{testText},
|
|
},
|
|
buffer: testChannel,
|
|
},
|
|
{
|
|
name: "direct message",
|
|
event: api.Message{
|
|
Command: irc.CmdPrivmsg, From: testNick, To: testOtherNick,
|
|
Body: []string{testText},
|
|
},
|
|
buffer: testOtherNick,
|
|
},
|
|
{
|
|
name: "notice",
|
|
event: api.Message{
|
|
Command: irc.CmdNotice, From: testNick, To: testChannel,
|
|
Body: []string{testText},
|
|
},
|
|
buffer: "(status)",
|
|
},
|
|
{
|
|
name: "join",
|
|
event: api.Message{
|
|
Command: irc.CmdJoin, From: testNick, To: testChannel,
|
|
},
|
|
buffer: testChannel,
|
|
},
|
|
{
|
|
name: "part",
|
|
event: api.Message{
|
|
Command: irc.CmdPart, From: testNick, To: testChannel,
|
|
},
|
|
buffer: testChannel,
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
app := &App{ui: NewUI(), nick: testNick}
|
|
runUI(t, app.ui)
|
|
|
|
app.handleServerMessage(&test.event)
|
|
|
|
lines, _ := bufferState(app.ui, test.buffer)
|
|
if lines != 1 {
|
|
t.Fatalf("got %d lines in %s, want 1", lines, test.buffer)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// bufferState returns the number of lines in the named
|
|
// buffer and how many of them are unread.
|
|
func bufferState(ui *UI, name string) (int, int) {
|
|
var lines, unread int
|
|
|
|
ui.app.QueueUpdate(func() {
|
|
buf := ui.getOrCreateBuffer(name)
|
|
lines = len(buf.Lines)
|
|
unread = buf.Unread
|
|
})
|
|
|
|
return lines, unread
|
|
}
|
|
|
|
// handledLines makes app.ui pass each typed line to
|
|
// app.handleInput, as Run does, and returns a channel that
|
|
// receives each line once it has been handled.
|
|
func handledLines(app *App) <-chan string {
|
|
handled := make(chan string)
|
|
|
|
app.ui.OnInput(func(text string) {
|
|
app.handleInput(text)
|
|
|
|
handled <- text
|
|
})
|
|
|
|
return handled
|
|
}
|
|
|
|
// waitHandled fails the test unless want is the next line handled,
|
|
// within eventLoopTimeout.
|
|
func waitHandled(t *testing.T, handled <-chan string, want string) {
|
|
t.Helper()
|
|
|
|
select {
|
|
case got := <-handled:
|
|
if got != want {
|
|
t.Fatalf("handled %q, want %q", got, want)
|
|
}
|
|
case <-time.After(eventLoopTimeout):
|
|
t.Fatalf("%q was not handled within %v", want, eventLoopTimeout)
|
|
}
|
|
}
|
|
|
|
// newServer starts a server that answers every request with
|
|
// body until the test ends.
|
|
func newServer(t *testing.T, body string) *httptest.Server {
|
|
t.Helper()
|
|
|
|
server := httptest.NewServer(http.HandlerFunc(
|
|
func(writer http.ResponseWriter, _ *http.Request) {
|
|
_, _ = io.WriteString(writer, body)
|
|
},
|
|
))
|
|
t.Cleanup(server.Close)
|
|
|
|
return server
|
|
}
|
|
|
|
// runUI runs ui on a simulated screen until the test ends.
|
|
func runUI(t *testing.T, ui *UI) {
|
|
t.Helper()
|
|
|
|
ui.app.SetScreen(tcell.NewSimulationScreen(""))
|
|
|
|
// One slot, so that Run's goroutine can end even after the
|
|
// cleanup below has stopped waiting for it.
|
|
done := make(chan error, 1)
|
|
|
|
go func() { done <- ui.Run() }()
|
|
|
|
t.Cleanup(func() {
|
|
ui.Stop()
|
|
|
|
select {
|
|
case err := <-done:
|
|
if err != nil {
|
|
t.Errorf("run ui: %v", err)
|
|
}
|
|
case <-time.After(eventLoopTimeout):
|
|
t.Error("the UI did not stop: its event loop stopped responding")
|
|
}
|
|
})
|
|
}
|