327 lines
11 KiB
Go
327 lines
11 KiB
Go
package bot
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
|
|
"github.com/slack-go/slack"
|
|
"github.com/slack-go/slack/slackevents"
|
|
|
|
"slackerbot/internal/acp"
|
|
"slackerbot/internal/manager"
|
|
"slackerbot/internal/model"
|
|
"slackerbot/internal/state"
|
|
"slackerbot/internal/testutil"
|
|
"slackerbot/internal/testutil/clustertest"
|
|
)
|
|
|
|
func TestOwnership(t *testing.T) {
|
|
dm := incoming{user: "U42", channel: "D9", dm: true}
|
|
if id, kind := dm.owner(); id != "U42" || kind != model.OwnerUser {
|
|
t.Fatalf("DM should be owned by the user, got %s %s", id, kind)
|
|
}
|
|
ch := incoming{user: "U42", channel: "C7"}
|
|
if id, kind := ch.owner(); id != "C7" || kind != model.OwnerChannel {
|
|
t.Fatalf("channel message should be owned by the channel, got %s %s", id, kind)
|
|
}
|
|
other := incoming{user: "U99", channel: "C7"}
|
|
a, ka := ch.owner()
|
|
b, kb := other.owner()
|
|
if model.MachineName(a, ka) != model.MachineName(b, kb) || model.MachineName(a, ka) != "c-c7" {
|
|
t.Fatal("two people in one channel should share a container")
|
|
}
|
|
if model.MachineName("U42", model.OwnerUser) != "u-u42" || !model.IsOurs("u-u42") || !model.IsOurs("c-c7") || model.IsOurs("web") {
|
|
t.Fatal("machine naming is off")
|
|
}
|
|
}
|
|
|
|
func TestTitle(t *testing.T) {
|
|
if got := title(" fix the build\nplease"); got != "fix the build" {
|
|
t.Fatal(got)
|
|
}
|
|
if got := title(strings.Repeat("é", 80)); !strings.HasSuffix(got, "…") || len([]rune(got)) != 61 {
|
|
t.Fatal(got)
|
|
}
|
|
}
|
|
|
|
type fakeSlack struct {
|
|
mu sync.Mutex
|
|
msgs map[string]string
|
|
order []string
|
|
n int
|
|
}
|
|
|
|
func (f *fakeSlack) handler(w http.ResponseWriter, r *http.Request) {
|
|
_ = r.ParseForm()
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
ts := r.Form.Get("ts")
|
|
if strings.HasSuffix(r.URL.Path, "chat.postMessage") {
|
|
f.n++
|
|
ts = "ts" + string(rune('0'+f.n))
|
|
f.order = append(f.order, ts)
|
|
}
|
|
f.msgs[ts] = r.Form.Get("text")
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_ = json.NewEncoder(w).Encode(map[string]any{"ok": true, "channel": "D1", "ts": ts, "text": f.msgs[ts]})
|
|
}
|
|
|
|
func TestStreamerSplitsLongReplies(t *testing.T) {
|
|
f := &fakeSlack{msgs: map[string]string{"ph": ""}, order: []string{"ph"}}
|
|
srv := httptest.NewServer(http.HandlerFunc(f.handler))
|
|
defer srv.Close()
|
|
api := slack.New("xoxb-test", slack.OptionAPIURL(srv.URL+"/"))
|
|
|
|
st := NewStreamer(api, "D1", "root", "ph")
|
|
line := strings.Repeat("x", 99) + "\n"
|
|
for i := 0; i < 80; i++ {
|
|
st.Update(acp.Update{Kind: "agent_message_chunk", Text: line})
|
|
}
|
|
st.Finish("end_turn", nil)
|
|
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
if len(f.order) != 3 {
|
|
t.Fatalf("want 3 messages, got %d", len(f.order))
|
|
}
|
|
var all strings.Builder
|
|
for _, ts := range f.order {
|
|
if len(f.msgs[ts]) > slackMsgLimit {
|
|
t.Fatalf("message %s too long: %d", ts, len(f.msgs[ts]))
|
|
}
|
|
all.WriteString(f.msgs[ts])
|
|
}
|
|
if all.Len() != 8000 {
|
|
t.Fatalf("text lost or duplicated: %d chars", all.Len())
|
|
}
|
|
}
|
|
|
|
func TestMoveTarget(t *testing.T) {
|
|
b := &Bot{}
|
|
for in, want := range map[string]string{"": "", "auto": "", "Slave-1": "slave-1", "to node-b": "node-b"} {
|
|
if got, ok := b.moveTarget(in); !ok || got != want {
|
|
t.Fatalf("move %q = %q %v, want %q", in, got, ok, want)
|
|
}
|
|
}
|
|
if _, ok := b.moveTarget("the files into the build folder"); ok {
|
|
t.Fatal("a normal sentence should go to the agent")
|
|
}
|
|
}
|
|
|
|
type slackLog struct {
|
|
mu sync.Mutex
|
|
n int
|
|
text map[string]string
|
|
under map[string]string
|
|
order []string
|
|
}
|
|
|
|
func (s *slackLog) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
_ = r.ParseForm()
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
ts := r.Form.Get("ts")
|
|
if strings.HasSuffix(r.URL.Path, "chat.postMessage") {
|
|
s.n++
|
|
ts = fmt.Sprintf("%d.0", s.n)
|
|
s.order = append(s.order, ts)
|
|
s.under[ts] = r.Form.Get("thread_ts")
|
|
}
|
|
if !strings.HasSuffix(r.URL.Path, "chat.getPermalink") {
|
|
s.text[ts] = r.Form.Get("text")
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_ = json.NewEncoder(w).Encode(map[string]any{"ok": true, "channel": "C1", "ts": ts, "permalink": "https://slack.example/" + ts})
|
|
}
|
|
|
|
func TestEveryMoveStartsAnAnnouncedThread(t *testing.T) {
|
|
c := clustertest.New(t)
|
|
c.AddOwner(t, testutil.HomeData(), false)
|
|
log := &slackLog{text: map[string]string{}, under: map[string]string{}}
|
|
srv := httptest.NewServer(log)
|
|
defer srv.Close()
|
|
b := &Bot{cfg: c.Cfg, store: c.Store, mgr: c.Mgr, api: slack.New("xoxb", slack.OptionAPIURL(srv.URL+"/")),
|
|
acps: map[string]*acp.ACP{}, busy: map[string]int{}}
|
|
|
|
b.moveFor(c.Ctx, "C1", "C1", "slave-1", "<@U1>", "100.0")
|
|
if _, err := c.Mgr.Migrate(c.Ctx, "C1", manager.MoveOptions{Target: "master"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
b.runMove(c.Ctx, "C1", "C1", manager.MoveOptions{}, "auto process (master was full), for <@U2>'s message", nil)
|
|
|
|
log.mu.Lock()
|
|
defer log.mu.Unlock()
|
|
var roots []string
|
|
for _, ts := range log.order {
|
|
if log.under[ts] == "" {
|
|
roots = append(roots, ts)
|
|
}
|
|
}
|
|
linked := 0
|
|
for ts, parent := range log.under {
|
|
if parent == "100.0" && strings.Contains(log.text[ts], "Follow the move here") {
|
|
linked++
|
|
}
|
|
}
|
|
if linked != 1 {
|
|
t.Fatalf("the thread where the move started should get one link to the move thread, got %d", linked)
|
|
}
|
|
if len(roots) != 2 {
|
|
t.Fatalf("want one new top-level message per move, got %d", len(roots))
|
|
}
|
|
checks := []string{"started by <@U1>: master → slave-1", "started by auto process (master was full), for <@U2>'s message"}
|
|
for i, root := range roots {
|
|
if !strings.Contains(log.text[root], checks[i]) || !strings.Contains(log.text[root], ":white_check_mark: done") {
|
|
t.Fatalf("root %d = %q", i, log.text[root])
|
|
}
|
|
replies := 0
|
|
for ts, parent := range log.under {
|
|
if parent == root {
|
|
replies++
|
|
if !strings.Contains(log.text[ts], "Moved from") {
|
|
t.Fatalf("progress reply = %q", log.text[ts])
|
|
}
|
|
}
|
|
}
|
|
if replies != 1 {
|
|
t.Fatalf("want progress in one thread reply, got %d", replies)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestManageCommandsInSlack(t *testing.T) {
|
|
log := &slackLog{text: map[string]string{}, under: map[string]string{}}
|
|
srv := httptest.NewServer(log)
|
|
defer srv.Close()
|
|
store, _ := state.Open(filepath.Join(t.TempDir(), "state.json"))
|
|
store.SeedPermissions(model.PermissionsConfig{Managers: []string{"UBOSS"}, Default: map[string][]string{"UBOSS": {"all"}}})
|
|
b := &Bot{store: store, api: slack.New("xoxb", slack.OptionAPIURL(srv.URL+"/"))}
|
|
ctx := context.Background()
|
|
say := func(user, text string) string {
|
|
m := incoming{user: user, channel: "C1", ts: "1.0", text: text}
|
|
if !b.command(ctx, m) {
|
|
return "(went to the agent)"
|
|
}
|
|
log.mu.Lock()
|
|
defer log.mu.Unlock()
|
|
return log.text[log.order[len(log.order)-1]]
|
|
}
|
|
|
|
if got := say("UANA", "grant <@UANA> all"); !strings.Contains(got, ":lock:") {
|
|
t.Fatalf("non-managers can't grant: %q", got)
|
|
}
|
|
if got := say("UBOSS", "grant <@UANA> move manage"); !strings.Contains(got, "<@UANA> can now: move, manage") {
|
|
t.Fatalf("manager grant: %q", got)
|
|
}
|
|
if got := say("UANA", "grant <@UCAL> scale"); !strings.Contains(got, "<@UCAL> can now: scale") {
|
|
t.Fatalf("channel manager grant: %q", got)
|
|
}
|
|
if got := say("UANA", "grant default <@UCAL> all"); !strings.Contains(got, ":lock:") {
|
|
t.Fatalf("channel managers can't touch the default list: %q", got)
|
|
}
|
|
if got := say("UANA", "managers add <@UCAL>"); !strings.Contains(got, ":lock:") {
|
|
t.Fatalf("only user managers add managers: %q", got)
|
|
}
|
|
if got := say("UBOSS", "managers remove <@UBOSS>"); !strings.Contains(got, "nobody able to manage") {
|
|
t.Fatalf("last manager guard: %q", got)
|
|
}
|
|
if got := say("UBOSS", "dm storage off"); !strings.Contains(got, "now turned off") {
|
|
t.Fatalf("dm toggle: %q", got)
|
|
}
|
|
if store.Permissions().Allowed(model.OwnerUser, "D1", "UX", model.ActStorage) {
|
|
t.Fatal("dm toggle not saved")
|
|
}
|
|
if got := say("UANA", "grant me access to the repo"); got != "(went to the agent)" {
|
|
t.Fatalf("plain sentence: %q", got)
|
|
}
|
|
if got := say("UANA", "permissions reset"); !strings.Contains(got, "default super-user list again") {
|
|
t.Fatalf("reset: %q", got)
|
|
}
|
|
if store.Permissions().Allowed(model.OwnerChannel, "C1", "UCAL", model.ActScale) {
|
|
t.Fatal("reset should drop the channel's own list")
|
|
}
|
|
}
|
|
|
|
func TestListenInThreads(t *testing.T) {
|
|
log := &slackLog{text: map[string]string{}, under: map[string]string{}}
|
|
srv := httptest.NewServer(log)
|
|
defer srv.Close()
|
|
store, _ := state.Open(filepath.Join(t.TempDir(), "state.json"))
|
|
_ = store.AddSession(&model.Session{Channel: "C1", ThreadTS: "1.0", OwnerID: "C1", ACPID: "a"})
|
|
b := &Bot{store: store, botID: "UBOT", api: slack.New("xoxb", slack.OptionAPIURL(srv.URL+"/"))}
|
|
ctx := context.Background()
|
|
say := func(m incoming) string {
|
|
if !b.listenCommand(ctx, m) {
|
|
return "(went to the agent)"
|
|
}
|
|
log.mu.Lock()
|
|
defer log.mu.Unlock()
|
|
last := log.order[len(log.order)-1]
|
|
if log.under[last] != m.threadTS {
|
|
t.Fatalf("reply went to thread %q, want %q", log.under[last], m.threadTS)
|
|
}
|
|
return log.text[last]
|
|
}
|
|
|
|
if b.listening("C1", "1.0", "hello") {
|
|
t.Fatal("threads only read mentions by default")
|
|
}
|
|
if got := say(incoming{channel: "C1", threadTS: "1.0", text: "/listen all-messages"}); !strings.Contains(got, "read every reply") {
|
|
t.Fatalf("thread toggle: %q", got)
|
|
}
|
|
if !b.listening("C1", "1.0", "hello") || b.listening("C1", "1.0", "<@UBOT> hello") || b.listening("C1", "9.0", "hello") {
|
|
t.Fatal("all-messages should read plain replies in session threads only, and leave mentions to app_mention")
|
|
}
|
|
if got := say(incoming{channel: "C1", threadTS: "1.0", text: "listen to me carefully"}); got != "(went to the agent)" {
|
|
t.Fatalf("plain sentence: %q", got)
|
|
}
|
|
if got := say(incoming{channel: "C1", threadTS: "9.0", text: "/listen all-messages"}); !strings.Contains(got, "no session") {
|
|
t.Fatalf("thread without a session: %q", got)
|
|
}
|
|
if got := say(incoming{channel: "C1", text: "/listen all-messages"}); !strings.Contains(got, "this channel's threads") {
|
|
t.Fatalf("channel default: %q", got)
|
|
}
|
|
_ = store.AddSession(&model.Session{Channel: "C1", ThreadTS: "2.0", OwnerID: "C1", ACPID: "b"})
|
|
if !b.listening("C1", "2.0", "hello") {
|
|
t.Fatal("new threads follow the channel default")
|
|
}
|
|
if got := say(incoming{channel: "D1", dm: true, text: "/listen only-mentions"}); !strings.Contains(got, "every message") {
|
|
t.Fatalf("DMs always listen: %q", got)
|
|
}
|
|
}
|
|
|
|
func TestStopReactionCancelsPrompt(t *testing.T) {
|
|
b := &Bot{}
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
b.running.Store("C1/5.0", cancel)
|
|
b.onReaction(&slackevents.ReactionAddedEvent{Reaction: "thumbsup", Item: slackevents.Item{Type: "message", Channel: "C1", Timestamp: "5.0"}})
|
|
if ctx.Err() != nil {
|
|
t.Fatal("other reactions must not cancel")
|
|
}
|
|
b.onReaction(&slackevents.ReactionAddedEvent{Reaction: "x", Item: slackevents.Item{Type: "message", Channel: "C1", Timestamp: "5.0"}})
|
|
if ctx.Err() == nil {
|
|
t.Fatal(":x: should cancel the reply")
|
|
}
|
|
}
|
|
|
|
func TestCommandsInAssistantThreads(t *testing.T) {
|
|
log := &slackLog{text: map[string]string{}, under: map[string]string{}}
|
|
srv := httptest.NewServer(log)
|
|
defer srv.Close()
|
|
store, _ := state.Open(filepath.Join(t.TempDir(), "state.json"))
|
|
b := &Bot{store: store, api: slack.New("xoxb", slack.OptionAPIURL(srv.URL+"/"))}
|
|
b.onMessage(context.Background(), incoming{user: "U1", channel: "D1", ts: "3.0", threadTS: "2.0", text: "help", dm: true})
|
|
log.mu.Lock()
|
|
defer log.mu.Unlock()
|
|
if len(log.order) != 1 || log.under[log.order[0]] != "2.0" || !strings.Contains(log.text[log.order[0]], "Commands") {
|
|
t.Fatalf("the first message of an assistant thread should run commands and answer in the thread: %v %v", log.order, log.under)
|
|
}
|
|
}
|