plumber/internal/discord/bot_test.go

package discord

import (
	"context"
	"strconv"
	"strings"
	"sync"
	"testing"
	"time"

	"plumber/internal/events"
	"plumber/internal/store"
)

type recordedSend struct {
	Kind      string
	ChannelID string
	Name      string
	Msg       Message
}

type fakeAPI struct {
	mu       sync.Mutex
	sends    []recordedSend
	edits    []recordedSend
	next     int
	failSend error
}

func (f *fakeAPI) SendToChannel(_ context.Context, channelID string, msg Message) (string, error) {
	return f.record("channel", channelID, "", msg)
}

func (f *fakeAPI) StartThread(_ context.Context, channelID, name string) (string, error) {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.next++
	id := "thread-" + strconv.Itoa(f.next)
	f.sends = append(f.sends, recordedSend{
		Kind:      "thread",
		ChannelID: channelID,
		Name:      name,
		Msg:       Message{ThreadName: name},
	})
	return id, nil
}

func (f *fakeAPI) SendToThread(_ context.Context, threadID string, msg Message) (string, error) {
	return f.record("thread-msg", threadID, "", msg)
}

func (f *fakeAPI) Edit(_ context.Context, channelID, messageID string, msg Message) error {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.edits = append(f.edits, recordedSend{
		Kind:      "edit",
		ChannelID: channelID,
		Name:      messageID,
		Msg:       msg,
	})
	return nil
}

func (f *fakeAPI) Close() error { return nil }

func (f *fakeAPI) record(kind, channelID, name string, msg Message) (string, error) {
	f.mu.Lock()
	defer f.mu.Unlock()
	if f.failSend != nil {
		return "", f.failSend
	}
	f.next++
	id := "msg-" + strconv.Itoa(f.next)
	f.sends = append(f.sends, recordedSend{Kind: kind, ChannelID: channelID, Name: name, Msg: msg})
	return id, nil
}

func TestOutboundRootReplyAndEdit(t *testing.T) {
	t.Parallel()

	links := newMemoryLinks()
	api := &fakeAPI{}
	bot := New("channel-1", links, api)
	ctx := context.Background()

	root := events.PostEvent{
		PostID:     "root-1",
		RootID:     "root-1",
		Title:      "Leaky sink",
		Body:       "Water under the cabinet.",
		City:       "Oakland",
		AuthorName: "sam",
		Permalink:  "https://www.askaplumberfirst.com/questions/root-1#post-root-1",
		Images:     []events.Image{{URL: "https://cdn.example/a.jpg"}, {URL: "https://cdn.example/b.jpg"}},
	}
	bot.Handle(ctx, events.PostCreated{PostEvent: root})

	if len(api.sends) != 2 ||
		api.sends[0].Kind != "thread" ||
		api.sends[1].Kind != "thread-msg" {
		t.Fatalf("root sends = %+v", api.sends)
	}
	if api.sends[0].ChannelID != "channel-1" ||
		api.sends[0].Name != "sam asks: Leaky sink" ||
		api.sends[1].ChannelID != "thread-1" {
		t.Fatalf("root routing = %+v", api.sends)
	}
	if got := api.sends[1].Msg.ImageURLs; len(got) != 2 || got[0] != "https://cdn.example/a.jpg" {
		t.Fatalf("root images = %v", got)
	}
	link, err := links.GetByPostID(ctx, "root-1")
	if err != nil || link.MessageID != "msg-2" || link.ThreadID != "thread-1" {
		t.Fatalf("root link = %+v, %v", link, err)
	}

	reply := events.PostEvent{
		PostID:     "reply-1",
		RootID:     "root-1",
		ParentID:   "root-1",
		Body:       "Replace the cartridge.",
		AuthorName: "plumber",
		Permalink:  "https://www.askaplumberfirst.com/questions/root-1#post-reply-1",
	}
	bot.Handle(ctx, events.PostCreated{PostEvent: reply})
	if len(api.sends) != 3 || api.sends[2].Kind != "thread-msg" || api.sends[2].ChannelID != "thread-1" {
		t.Fatalf("reply sends = %+v", api.sends)
	}
	replyLink, err := links.GetByPostID(ctx, "reply-1")
	if err != nil || replyLink.MessageID != "msg-3" || replyLink.ThreadID != "" {
		t.Fatalf("reply link = %+v, %v", replyLink, err)
	}

	root.Body = "Updated leak."
	bot.Handle(ctx, events.PostUpdated{PostEvent: root})
	if len(api.edits) != 1 || api.edits[0].ChannelID != "thread-1" || api.edits[0].Name != "msg-2" {
		t.Fatalf("root edit = %+v", api.edits)
	}
	if api.edits[0].Msg.Description != "Updated leak." {
		t.Fatalf("root edit body = %+v", api.edits[0].Msg)
	}

	reply.Body = "Use a ceramic cartridge."
	bot.Handle(ctx, events.PostUpdated{PostEvent: reply})
	if len(api.edits) != 2 || api.edits[1].ChannelID != "thread-1" || api.edits[1].Name != "msg-3" {
		t.Fatalf("reply edit = %+v", api.edits)
	}
}

func TestOutboundSkipsReplyWithoutRootLink(t *testing.T) {
	t.Parallel()

	api := &fakeAPI{}
	bot := New("channel-1", newMemoryLinks(), api)
	bot.Handle(context.Background(), events.PostCreated{PostEvent: events.PostEvent{
		PostID:   "reply-1",
		RootID:   "missing",
		ParentID: "missing",
		Body:     "Orphan reply",
	}})
	if len(api.sends) != 0 {
		t.Fatalf("unexpected sends %+v", api.sends)
	}
}

func TestOutboundSkipsAlreadyLinkedPost(t *testing.T) {
	t.Parallel()

	links := newMemoryLinks()
	api := &fakeAPI{}
	bot := New("channel-1", links, api)
	if err := links.Upsert(context.Background(), store.DiscordLink{
		PostID:    "reply-1",
		MessageID: "d-reply-1",
	}); err != nil {
		t.Fatal(err)
	}
	if err := links.Upsert(context.Background(), store.DiscordLink{
		PostID:    "root-1",
		MessageID: "d-root",
		ThreadID:  "thread-1",
	}); err != nil {
		t.Fatal(err)
	}
	bot.Handle(context.Background(), events.PostCreated{PostEvent: events.PostEvent{
		PostID:   "reply-1",
		RootID:   "root-1",
		ParentID: "root-1",
		Body:     "Already on Discord.",
	}})
	if len(api.sends) != 0 {
		t.Fatalf("echoed already-linked reply: %+v", api.sends)
	}
}

func TestOutboundUpdateWithoutLinkCreates(t *testing.T) {
	t.Parallel()

	links := newMemoryLinks()
	api := &fakeAPI{}
	bot := New("channel-1", links, api)
	bot.Handle(context.Background(), events.PostUpdated{PostEvent: events.PostEvent{
		PostID: "root-2",
		RootID: "root-2",
		Title:  "Late question",
		Body:   "Created while Discord was down.",
	}})
	link, err := links.GetByPostID(context.Background(), "root-2")
	if err != nil || link.ThreadID == "" || len(api.sends) != 2 {
		t.Fatalf("late create link=%+v sends=%+v err=%v", link, api.sends, err)
	}
}

func TestOutboundAttachesVideoFile(t *testing.T) {
	t.Parallel()

	bus := events.New()
	defer bus.Close()
	events.SubscribeRelease(bus)
	links := newMemoryLinks()
	api := &fakeAPI{}
	bot := New("channel-1", links, api)
	bot.bus = bus

	released := make(chan struct{})
	bot.Handle(context.Background(), events.PostCreated{
		PostEvent: events.PostEvent{
			PostID:     "root-1",
			RootID:     "root-1",
			Title:      "Valve clip",
			Body:       "Watch the handle.",
			AuthorName: "sam",
			Permalink:  "https://www.askaplumberfirst.com/questions/root-1#post-root-1",
			Images:     []events.Image{{URL: "https://cdn.example/clip.mp4", Kind: "video"}},
		},
		Media: []events.Media{{
			Name:        "clip.mp4",
			ContentType: "video/mp4",
			Kind:        "video",
			Bytes:       []byte("fake-mp4"),
		}},
		Release: func() { close(released) },
	})

	if len(api.sends) != 3 ||
		api.sends[1].Kind != "thread-msg" ||
		api.sends[2].Kind != "thread-msg" {
		t.Fatalf("sends = %+v", api.sends)
	}
	if len(api.sends[1].Msg.Files) != 0 {
		t.Fatalf("text message files = %+v", api.sends[1].Msg.Files)
	}
	files := api.sends[2].Msg.Files
	if len(files) != 1 || files[0].Name != "clip.mp4" || files[0].ContentType != "video/mp4" {
		t.Fatalf("video files = %+v", files)
	}
	content := messageContent(api.sends[1].Msg)
	if strings.Contains(content, "https://cdn.example/clip.mp4") {
		t.Fatalf("content still has video URL: %q", content)
	}
	select {
	case <-released:
	case <-time.After(time.Second):
		t.Fatal("PostedToDiscord did not release")
	}
}

func TestOutboundPhotosThenVideo(t *testing.T) {
	t.Parallel()

	api := &fakeAPI{}
	bot := New("channel-1", newMemoryLinks(), api)
	bot.Handle(context.Background(), events.PostCreated{
		PostEvent: events.PostEvent{
			PostID:     "root-1",
			RootID:     "root-1",
			Title:      "Valve clip",
			Body:       "Photo and video.",
			AuthorName: "sam",
			Images: []events.Image{
				{URL: "https://cdn.example/a.jpg"},
				{URL: "https://cdn.example/clip.mp4", Kind: "video"},
			},
		},
		Media: []events.Media{
			{Name: "still.jpg", ContentType: "image/jpeg", Kind: "image", Bytes: []byte("jpeg")},
			{Name: "clip.mp4", ContentType: "video/mp4", Kind: "video", Bytes: []byte("mp4")},
		},
	})
	if len(api.sends) != 3 ||
		api.sends[1].Kind != "thread-msg" ||
		api.sends[2].Kind != "thread-msg" {
		t.Fatalf("sends = %+v", api.sends)
	}
	photos := api.sends[1].Msg.Files
	if len(photos) != 0 {
		t.Fatalf("text message should not attach files: %+v", photos)
	}
	if got := api.sends[1].Msg.ImageURLs; len(got) != 1 || got[0] != "https://cdn.example/a.jpg" {
		t.Fatalf("text message images = %v", got)
	}
	if embeds := toEmbeds(api.sends[1].Msg); len(embeds) == 0 || embeds[0].Image == nil || embeds[0].Image.URL != "https://cdn.example/a.jpg" {
		t.Fatalf("text embeds = %+v", toEmbeds(api.sends[1].Msg))
	}
	videos := api.sends[2].Msg.Files
	if len(videos) != 1 || videos[0].Name != "clip.mp4" {
		t.Fatalf("video files = %+v", videos)
	}
}

func TestOutboundReleasesWhenAlreadyLinked(t *testing.T) {
	t.Parallel()

	links := newMemoryLinks()
	if err := links.Upsert(context.Background(), store.DiscordLink{
		PostID:    "root-1",
		MessageID: "d-root",
		ThreadID:  "thread-1",
	}); err != nil {
		t.Fatal(err)
	}
	released := false
	bot := New("channel-1", links, &fakeAPI{})
	bot.Handle(context.Background(), events.PostCreated{
		PostEvent: events.PostEvent{PostID: "root-1", RootID: "root-1", Title: "Already posted"},
		Release:   func() { released = true },
	})
	if !released {
		t.Fatal("skipped send did not release held upload")
	}
}

func TestFormatMessage(t *testing.T) {
	t.Parallel()

	got := formatMessage(events.PostEvent{
		Title:      "Leaky sink",
		Body:       "It drips.",
		City:       "Oakland",
		AuthorName: "sam",
		Permalink:  "https://example.com/q",
		Images: []events.Image{
			{URL: "https://cdn.example/a.jpg", Description: "ignored"},
			{URL: "https://cdn.example/clip.mp4", Kind: "video"},
		},
	})
	if got.Title != "Leaky sink" ||
		got.Description != "It drips." ||
		got.City != "Oakland" ||
		got.Author != "sam" ||
		got.URL != "https://example.com/q" ||
		got.ThreadName != "sam asks: Leaky sink" ||
		len(got.ImageURLs) != 1 || got.ImageURLs[0] != "https://cdn.example/a.jpg" ||
		len(got.VideoURLs) != 1 || got.VideoURLs[0] != "https://cdn.example/clip.mp4" {
		t.Fatalf("format = %+v", got)
	}

	reply := formatMessage(events.PostEvent{Body: "Thanks", AuthorName: ""})
	if reply.Title != "Reply" || reply.Author != "Someone" || reply.ThreadName != "Someone asks: Question" {
		t.Fatalf("reply format = %+v", reply)
	}
	content := messageContent(got)
	if strings.Contains(content, "Leaky sink") ||
		!strings.Contains(content, "It drips.") ||
		!strings.Contains(content, "Oakland") ||
		!strings.Contains(content, "https://cdn.example/a.jpg") ||
		!strings.Contains(content, "https://cdn.example/clip.mp4") {
		t.Fatalf("content = %q", content)
	}
	if publicURL("/questions/x") != "" || publicURL("http://localhost:8080/q") != "" {
		t.Fatal("localhost or relative permalink should not be an embed URL")
	}
}

func TestFromEnvDisabled(t *testing.T) {
	t.Setenv("DISCORD_BOT_TOKEN", "")
	t.Setenv("DISCORD_CHANNEL_ID", "")
	bot, err := FromEnv(newMemoryLinks(), nil, nil)
	if err != nil || bot != nil {
		t.Fatalf("disabled FromEnv = (%v, %v)", bot, err)
	}
}

func TestFromEnvRequiresBoth(t *testing.T) {
	t.Setenv("DISCORD_BOT_TOKEN", "token")
	t.Setenv("DISCORD_CHANNEL_ID", "")
	if _, err := FromEnv(newMemoryLinks(), nil, nil); err == nil {
		t.Fatal("expected error when channel is missing")
	}
	t.Setenv("DISCORD_BOT_TOKEN", "")
	t.Setenv("DISCORD_CHANNEL_ID", "channel")
	if _, err := FromEnv(newMemoryLinks(), nil, nil); err == nil {
		t.Fatal("expected error when token is missing")
	}
}

func TestMemoryLinkUpsertKeepsThread(t *testing.T) {
	t.Parallel()

	links := newMemoryLinks()
	ctx := context.Background()
	if err := links.Upsert(ctx, store.DiscordLink{PostID: "p", MessageID: "m1", ThreadID: "t1"}); err != nil {
		t.Fatal(err)
	}
	if err := links.Upsert(ctx, store.DiscordLink{PostID: "p", MessageID: "m2"}); err != nil {
		t.Fatal(err)
	}
	got, err := links.GetByPostID(ctx, "p")
	if err != nil || got.MessageID != "m2" || got.ThreadID != "t1" {
		t.Fatalf("upsert keep thread = %+v, %v", got, err)
	}
	if _, err := links.GetByMessageID(ctx, "m2"); err != nil {
		t.Fatal(err)
	}
	if _, err := links.GetRootByThreadID(ctx, "t1"); err != nil {
		t.Fatal(err)
	}
}