thermograph/backend/daemon/internal/gateway/message_test.go

// Triage tests: every behaviour asserted by the Python suite
// (backend/tests/notifications/test_discord_bot.py) has an equivalent here,
// minus the ephemeral-flag drop — the /internal/discord/grade route now
// returns gateway-ready JSON, so that concern moved to the Python side.

package gateway

import (
	"encoding/json"
	"strings"
	"testing"
)

const botID = "999"

// testMsg mirrors the Python suite's _msg fixture: author "1" (not a bot),
// message id 42 in channel 77, guild 5 unless overridden.
func testMsg(content string, opts ...func(*gwMessage)) *gwMessage {
	m := &gwMessage{
		ID:        "42",
		ChannelID: "77",
		GuildID:   "5",
		Content:   content,
		Author:    gwAuthor{ID: "1"},
	}
	for _, opt := range opts {
		opt(m)
	}
	return m
}

func fromBot() func(*gwMessage) {
	return func(m *gwMessage) { m.Author.Bot = true }
}

func fromID(id string) func(*gwMessage) {
	return func(m *gwMessage) { m.Author.ID = snowflake(id) }
}

func mentioning(ids ...string) func(*gwMessage) {
	return func(m *gwMessage) {
		for _, id := range ids {
			m.Mentions = append(m.Mentions, gwAuthor{ID: snowflake(id)})
		}
	}
}

func asDM() func(*gwMessage) {
	return func(m *gwMessage) { m.GuildID = "" }
}

// --- when the bot stays silent ----------------------------------------------

func TestIgnoresOtherBots(t *testing.T) {
	act, _ := triage(testMsg("<@999> Phoenix", fromID("8"), fromBot(), mentioning(botID)), botID, true)
	if act != actSilent {
		t.Fatalf("bot author should be ignored, got action %d", act)
	}
}

func TestIgnoresItsOwnMessages(t *testing.T) {
	act, _ := triage(testMsg("hello", fromID(botID), mentioning(botID)), botID, true)
	if act != actSilent {
		t.Fatalf("own message should be ignored, got action %d", act)
	}
}

func TestIgnoresGuildMessageWithoutAMention(t *testing.T) {
	act, _ := triage(testMsg("just chatting"), botID, true)
	if act != actSilent {
		t.Fatalf("unmentioned guild message should be ignored, got action %d", act)
	}
}

// --- when the bot replies ----------------------------------------------------

func TestMentionWithCityGrades(t *testing.T) {
	act, query := triage(testMsg("<@999> Phoenix", mentioning(botID)), botID, true)
	if act != actGrade || query != "Phoenix" {
		t.Fatalf("want grade %q, got action %d query %q", "Phoenix", act, query)
	}
}

func TestLegacyNicknameMentionIsStripped(t *testing.T) {
	act, query := triage(testMsg("<@!999>   Tokyo", mentioning(botID)), botID, true)
	if act != actGrade || query != "Tokyo" {
		t.Fatalf("want grade %q, got action %d query %q", "Tokyo", act, query)
	}
}

func TestDMNeedsNoMention(t *testing.T) {
	act, query := triage(testMsg("Berlin", asDM()), botID, true)
	if act != actGrade || query != "Berlin" {
		t.Fatalf("want grade %q, got action %d query %q", "Berlin", act, query)
	}
}

func TestDMTrimsButKeepsInnerWhitespace(t *testing.T) {
	// Parity with the Python DM path (.strip(), not a collapse): only the
	// edges are trimmed.
	act, query := triage(testMsg("  New   York  ", asDM()), botID, true)
	if act != actGrade || query != "New   York" {
		t.Fatalf("want grade %q, got action %d query %q", "New   York", act, query)
	}
}

// --- handing the channel surface to the desktop agent ------------------------

func TestGuildMentionsOffStaysSilentInChannels(t *testing.T) {
	// With the conversational agent live, a grade card here would be the second
	// answer to the same mention.
	act, _ := triage(testMsg("<@999> Phoenix", mentioning(botID)), botID, false)
	if act != actSilent {
		t.Fatalf("guild mention should be silent when the agent owns it, got action %d", act)
	}
	// The bare-mention help line is a reply too, and would double up the same way.
	act, _ = triage(testMsg("<@999>", mentioning(botID)), botID, false)
	if act != actSilent {
		t.Fatalf("bare guild mention should be silent too, got action %d", act)
	}
}

func TestGuildMentionsOffStillAnswersDMs(t *testing.T) {
	// The agent polls guild channels only, so a DM has no other responder —
	// staying silent here would just drop the message.
	act, query := triage(testMsg("Berlin", asDM()), botID, false)
	if act != actGrade || query != "Berlin" {
		t.Fatalf("DMs must keep working, got action %d query %q", act, query)
	}
}

func TestMentionWithNoQueryGivesHelp(t *testing.T) {
	act, query := triage(testMsg("<@999>", mentioning(botID)), botID, true)
	if act != actHelp || query != "" {
		t.Fatalf("want help, got action %d query %q", act, query)
	}
	if !strings.Contains(strings.ToLower(helpText), "mention me") {
		t.Fatalf("help text lost its instruction: %q", helpText)
	}
}

// --- helpers -----------------------------------------------------------------

func TestStripMentionsHandlesBothForms(t *testing.T) {
	if got := stripMentions("<@999> <@!999>  Sao Paulo", botID); got != "Sao Paulo" {
		t.Fatalf("want %q, got %q", "Sao Paulo", got)
	}
}

func TestIsDMIsTrueWithoutGuildID(t *testing.T) {
	if !isDM(testMsg("x", asDM())) {
		t.Fatal("message without guild_id should be a DM")
	}
	if isDM(testMsg("x")) {
		t.Fatal("message with guild_id should not be a DM")
	}
}

func TestSnowflakeAcceptsStringOrNumber(t *testing.T) {
	// The Python compared ids through str() coercion; a numeric id in the
	// payload must still count as a mention.
	var m gwMessage
	raw := `{"id":42,"channel_id":"77","guild_id":"5","content":"<@999> Lima",
	         "author":{"id":1,"bot":false},"mentions":[{"id":999}]}`
	if err := json.Unmarshal([]byte(raw), &m); err != nil {
		t.Fatalf("unmarshal: %v", err)
	}
	if m.ID != "42" || string(m.Author.ID) != "1" {
		t.Fatalf("numeric ids mis-decoded: id=%q author=%q", m.ID, m.Author.ID)
	}
	act, query := triage(&m, botID, true)
	if act != actGrade || query != "Lima" {
		t.Fatalf("want grade %q, got action %d query %q", "Lima", act, query)
	}
}

func TestIntentsExcludeMessageContent(t *testing.T) {
	// The no-privileged-intent constraint is load-bearing: adding
	// MESSAGE_CONTENT (1<<15) silently would make Discord close the gateway
	// with 4014 until the portal review happens.
	if intents != intentGuilds|intentGuildMessages|intentDirectMessages {
		t.Fatalf("unexpected intents bitfield: %d", intents)
	}
	if intents&(1<<15) != 0 {
		t.Fatal("intents must not request MESSAGE_CONTENT")
	}
}