Netpulse_SasS/server/internal/alerting/telegram_callback_test.go

package alerting

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

	"github.com/netpulse/netpulse/server/internal/store"
)

// Мережі тут немає навмисно: усе, що вирішує долю натискання, —
// розбір рядка й пошук каналу за чатом. Тест, якому потрібен живий
// бот, не запускають, а отже й не пишуть.

const goodUUID = "3f2b1a5c-9d84-4e77-b0c1-2a6f8e5d4c31"

func TestParseCallbackDataAcceptsOwnFormat(t *testing.T) {
	for _, kind := range []string{"ack", "mute"} {
		got, err := parseCallbackData(kind + ":" + goodUUID)
		if err != nil {
			t.Fatalf("%s: %v", kind, err)
		}
		if got.Kind != kind || got.ID != goodUUID {
			t.Errorf("%s: отримали %+v", kind, got)
		}
	}
}

// callback_data приходить рядком і нічим не підписаний, тож усе, що не
// збігається з нашим форматом до символу, має відхилятись до першого
// звернення до бази.
func TestParseCallbackDataRejectsAnythingElse(t *testing.T) {
	bad := map[string]string{
		"порожньо":            "",
		"без роздільника":     "ack" + goodUUID,
		"невідома дія":        "close:" + goodUUID,
		"порожній id":         "ack:",
		"не uuid":             "ack:12345",
		"майже uuid":          "ack:3f2b1a5c-9d84-4e77-b0c1-2a6f8e5d4c3",
		"нешістнадцятковий":   "ack:3f2b1a5c-9d84-4e77-b0c1-2a6f8e5d4czz",
		"дефіси не на місці":  "ack:3f2b1a5c9d84-4e77-b0c1-2a6f8e5d4c311",
		"спроба ін'єкції":     "ack:' OR 1=1 --",
		"два роздільники":     "ack:mute:" + goodUUID,
		"довше за стелю":      "ack:" + strings.Repeat("a", 70),
		"регістр дії":         "ACK:" + goodUUID,
		"пробіл перед дією":   " ack:" + goodUUID,
		"порожній ідентиф-р ": "mute:",
	}
	for name, raw := range bad {
		if _, err := parseCallbackData(raw); err == nil {
			t.Errorf("%s (%q): очікували відмову", name, raw)
		}
	}
}

// Верхній регістр у uuid трапляється у вивантаженнях із інших систем і
// коректний за RFC — відкидати його немає підстав.
func TestParseCallbackDataAcceptsUpperCaseUUID(t *testing.T) {
	if _, err := parseCallbackData("ack:" + strings.ToUpper(goodUUID)); err != nil {
		t.Errorf("верхній регістр uuid має прийматись: %v", err)
	}
}

// ---------------------------------------------------------------------
// Кабінет береться з чату, а не з кнопки
// ---------------------------------------------------------------------

func tgChannel(id, tenant string, cfg string) store.Channel {
	return store.Channel{ID: id, TenantID: tenant, Kind: "telegram",
		Name: id, Enabled: true, Config: json.RawMessage(cfg)}
}

func TestMatchChannelFindsTenantByChat(t *testing.T) {
	chans := []store.Channel{
		tgChannel("c1", "t1", `{"chat_id":-1001111111111}`),
		tgChannel("c2", "t2", `{"chat_id":"-1002222222222"}`),
	}

	got, ok := matchChannel(chans, -1002222222222, 0)
	if !ok || got.TenantID != "t2" {
		t.Fatalf("очікували канал t2, отримали %+v (ok=%v)", got.ID, ok)
	}

	// chat_id пишуть і числом, і рядком — на пошук кабінету це впливати
	// не має (див. TestTelegramChatIDAcceptsBothForms).
	if got, ok := matchChannel(chans, -1001111111111, 0); !ok || got.TenantID != "t1" {
		t.Fatalf("числова форма chat_id не знайшлася: %+v (ok=%v)", got.ID, ok)
	}
}

// Головна перевірка приймача: натискання з чату, якого немає в жодному
// каналі, не має давати кабінету взагалі. Інакше досить було б знати
// формат кнопки, щоб підтвердити чужий алерт зі свого чату.
func TestMatchChannelRejectsUnknownChat(t *testing.T) {
	chans := []store.Channel{tgChannel("c1", "t1", `{"chat_id":-1001111111111}`)}

	if _, ok := matchChannel(chans, -1009999999999, 0); ok {
		t.Fatal("чужий чат не має зіставлятися з каналом")
	}
	if _, ok := matchChannel(nil, -1001111111111, 0); ok {
		t.Fatal("порожній перелік каналів не має нічого знаходити")
	}
}

// Кривий config каналу не має ламати пошук для решти: один зіпсований
// рядок гасив би кнопки всім, хто ділить із ним бота.
func TestMatchChannelSkipsBrokenConfig(t *testing.T) {
	chans := []store.Channel{
		tgChannel("broken", "t1", `{"chat_id":`),
		tgChannel("good", "t2", `{"chat_id":-1002222222222}`),
	}
	got, ok := matchChannel(chans, -1002222222222, 0)
	if !ok || got.ID != "good" {
		t.Fatalf("очікували good, отримали %+v (ok=%v)", got.ID, ok)
	}
}

// Той самий чат із гілками: точніший канал (із message_thread_id) має
// вигравати, інакше алерт із гілки «Мережа» підтверджувався б від імені
// каналу, налаштованого на весь чат.
func TestMatchChannelPrefersThread(t *testing.T) {
	chans := []store.Channel{
		tgChannel("whole", "t1", `{"chat_id":-100777}`),
		tgChannel("thread", "t1", `{"chat_id":-100777,"thread_id":42}`),
	}
	if got, _ := matchChannel(chans, -100777, 42); got.ID != "thread" {
		t.Errorf("для гілки 42 очікували канал thread, отримали %s", got.ID)
	}
	if got, _ := matchChannel(chans, -100777, 0); got.ID != "whole" {
		t.Errorf("поза гілкою очікували канал whole, отримали %s", got.ID)
	}
}

// ---------------------------------------------------------------------
// Видима ідемпотентність
// ---------------------------------------------------------------------

// Друге натискання має привести повідомлення в той самий вигляд, що й
// перше. Другий рядок «Підтверджено» під тим самим алертом читався б як
// два різні підтвердження.
func TestWithStatusAddsLineOnlyOnce(t *testing.T) {
	line := ackLine("ops@example.com", time.Date(2026, 8, 27, 3, 12, 0, 0, time.UTC))
	first := withStatus("🔴 HIGH: sw1 не відповідає", line)

	if !strings.Contains(first, "ops@example.com") {
		t.Fatalf("у підсумку немає автора: %q", first)
	}
	if second := withStatus(first, line); second != first {
		t.Errorf("повторне дописування змінило текст:\n%q\n%q", first, second)
	}
}

func TestWithStatusKeepsWithinTelegramLimit(t *testing.T) {
	long := strings.Repeat("щ", maxMessageText)
	got := withStatus(long, muteLine("ops@example.com", time.Now().Add(time.Hour)))

	if len(got) > maxMessageText {
		t.Fatalf("довжина %d перевищує стелю %d", len(got), maxMessageText)
	}
	if !strings.Contains(got, "Заглушено до") {
		t.Errorf("обрізали не з того боку — підсумок зник:\n%q", got[:80])
	}
}

// ---------------------------------------------------------------------
// Команда прив'язки
// ---------------------------------------------------------------------

func TestParseLinkCommand(t *testing.T) {
	cases := []struct {
		in     string
		code   string
		isLink bool
	}{
		{"/link ABCD2345", "ABCD2345", true},
		// У групі Telegram дописує ім'я бота до команди сам.
		{"/link@netpulse_bot ABCD2345", "ABCD2345", true},
		// Телефон охоче виправляє набране на нижній регістр.
		{"/link abcd2345", "ABCD2345", true},
		{"  /link   ABCD2345  ", "ABCD2345", true},
		// Команда без коду — привід підказати, а не мовчати.
		{"/link", "", true},
		// Усе інше бот ігнорує: він часто стоїть у робочому чаті.
		{"привіт", "", false},
		{"", "", false},
		{"/start", "", false},
		{"скажи /link ABCD2345", "", false},
	}
	for _, c := range cases {
		code, isLink := parseLinkCommand(c.in)
		if code != c.code || isLink != c.isLink {
			t.Errorf("%q: отримали (%q, %v), очікували (%q, %v)",
				c.in, code, isLink, c.code, c.isLink)
		}
	}
}

// Прив'язки немає — у відмові має бути видно, ЯКИЙ саме акаунт стукав:
// інакше адміністратор не зрозуміє, кого шукати.
func TestDisplayNameFallsBackToIdentity(t *testing.T) {
	if got := tgDisplayName(tgUser{ID: 77, Username: "ops"}); got != "@ops" {
		t.Errorf("отримали %q", got)
	}
	if got := tgDisplayName(tgUser{ID: 77, FirstName: "Іван", LastName: "П."}); got != "Іван П." {
		t.Errorf("отримали %q", got)
	}
	if got := tgDisplayName(tgUser{ID: 77}); got != "77" {
		t.Errorf("отримали %q", got)
	}
}

// ---------------------------------------------------------------------
// Розбір оновлення цілком
// ---------------------------------------------------------------------

// Перевірка на справжній формі відповіді Bot API: поля, за якими
// вирішується кабінет і особа, мають доїжджати повністю.
func TestUpdateDecodesFieldsUsedForAuthorisation(t *testing.T) {
	raw := `{
	  "update_id": 500123,
	  "callback_query": {
	    "id": "4382bfdwdsb323b2d9",
	    "from": {"id": 9876543210, "is_bot": false, "username": "ops"},
	    "message": {
	      "message_id": 4210,
	      "chat": {"id": -1001111111111, "type": "supergroup"},
	      "message_thread_id": 42,
	      "text": "🔴 HIGH: sw1 не відповідає"
	    },
	    "data": "ack:` + goodUUID + `"
	  }
	}`

	var u tgUpdate
	if err := json.Unmarshal([]byte(raw), &u); err != nil {
		t.Fatal(err)
	}
	cq := u.CallbackQuery
	if cq == nil || cq.Message == nil {
		t.Fatal("callback_query не розібрався")
	}
	// 64-бітний id: на нових акаунтах Telegram він уже не вміщається в
	// int32, і мовчазне обрізання тут означало б прив'язку не до тієї
	// людини.
	if cq.From.ID != 9876543210 {
		t.Errorf("from.id = %d", cq.From.ID)
	}
	if cq.Message.Chat.ID != -1001111111111 || cq.Message.ThreadID != 42 {
		t.Errorf("чат розібрався як %d/%d", cq.Message.Chat.ID, cq.Message.ThreadID)
	}
	if act, err := parseCallbackData(cq.Data); err != nil || act.Kind != "ack" {
		t.Errorf("дія розібралась як %+v (%v)", act, err)
	}
}