Files
archie/internal/channels/telegram/update_test.go
T
sam f7815d3b62 fix(channels): delete unreachable Telegram webhook delivery mode
telegram.New only ever constructed with empty webhookURL/webhookSecret
(telegram_setup.go) and config.TelegramConfig has no field to set them, so
the SetWebhook/StartWebhook branch, WebhookHandler, and webhook teardown in
Stop were dead code exercised only by tests. Long-polling is the only
reachable mode; delete the webhook path and its ConfigSchema properties so
the schema no longer advertises unsupported config.
2026-09-15 10:18:48 +10:00

423 lines
17 KiB
Go

package telegram
import (
"context"
"errors"
"log/slog"
"os"
"path/filepath"
"strings"
"testing"
"github.com/go-telegram/bot/models"
"github.com/samcharles93/archie-core/internal/releaseupdate"
)
var errFixtureInstall = errors.New("build failed: exit status 1")
func TestUpdateShowsComponentSectionsAndActions(t *testing.T) {
g := New("1:test", []int64{42}, slog.Default())
g.Updates = &updateStub{snapshot: releaseupdate.Snapshot{Components: []releaseupdate.Component{
{ID: "gateway", Label: "THE GATEWAY", Installed: "v0.1.0", Available: "v0.1.1", Changelog: "- Clearer help"},
{ID: "runtime", Label: "THE RUNTIME", Installed: "v0.1.0"},
}}}
b, requests := newTelegramTestBot(t)
g.updateHandler()(context.Background(), b, &models.Update{Message: &models.Message{
From: &models.User{ID: 42}, Chat: models.Chat{ID: 7, Type: models.ChatTypePrivate}, Text: "/update",
}})
if len(*requests) != 1 || (*requests)[0].method != "sendMessage" {
t.Fatalf("requests = %#v, want update message", *requests)
}
text := (*requests)[0].form["text"]
for _, want := range []string{"Archie has an update available:", "--- THE GATEWAY ---", "v0.1.1 available", "- Clearer help", "--- THE RUNTIME ---", "No runtime changes"} {
if !strings.Contains(text, want) {
t.Errorf("update text missing %q: %q", want, text)
}
}
if !strings.Contains((*requests)[0].form["reply_markup"], updateApproveCallback) || !strings.Contains((*requests)[0].form["reply_markup"], updateDeferCallback) {
t.Errorf("update keyboard = %q", (*requests)[0].form["reply_markup"])
}
}
// TestInstallUpdateStreamsProgressAndReportsSuccess: the phase-1 summary
// must be distinct from a final "it worked" claim -- the daemon has not
// restarted yet when this message is sent, so it can only promise that the
// build/install step succeeded and a restart is queued.
func TestInstallUpdateStreamsProgressAndReportsSuccess(t *testing.T) {
g := New("1:test", []int64{42}, slog.Default())
stub := &updateStub{
progressText: []string{"==> fetching", "==> building"},
result: releaseupdate.Result{
Previous: map[string]string{releaseupdate.ComponentDaemon: "1.0.0", releaseupdate.ComponentAgent: "1.0.0"},
Installed: map[string]string{releaseupdate.ComponentDaemon: "1.1.0", releaseupdate.ComponentAgent: "1.0.0"},
RestartRequested: true,
},
}
g.Updates = stub
b, requests := newTelegramTestBot(t)
message := &models.Message{Chat: models.Chat{ID: 7}, ID: 100, MessageThreadID: 3}
g.installUpdate(context.Background(), b, &models.CallbackQuery{
From: models.User{ID: 42},
Message: models.MaybeInaccessibleMessage{Message: message},
}, releaseupdate.Snapshot{})
if stub.gotMeta.Channel != "telegram" || stub.gotMeta.ChatID != 7 || stub.gotMeta.ThreadID != 3 {
t.Errorf("gotMeta = %#v, want channel/chat/thread forwarded", stub.gotMeta)
}
if len(*requests) == 0 {
t.Fatal("no requests sent")
}
last := (*requests)[len(*requests)-1]
if last.method != "editMessageText" {
t.Fatalf("last request method = %q, want editMessageText", last.method)
}
text := last.form["text"]
for _, want := range []string{"1.0.0 → 1.1.0", "restart queued", "healthy"} {
if !strings.Contains(strings.ToLower(text), strings.ToLower(want)) {
t.Errorf("summary missing %q: %q", want, text)
}
}
}
// TestInstallUpdateReportsBuildFailureWithoutClaimingRestart: a failure
// during build/install must say nothing was restarted -- that's true only
// because the reference script never reaches the restart step on a
// non-zero exit.
func TestInstallUpdateReportsBuildFailureWithoutClaimingRestart(t *testing.T) {
g := New("1:test", []int64{42}, slog.Default())
stub := &updateStub{installErr: errFixtureInstall}
g.Updates = stub
b, requests := newTelegramTestBot(t)
message := &models.Message{Chat: models.Chat{ID: 7}, ID: 100}
g.installUpdate(context.Background(), b, &models.CallbackQuery{
From: models.User{ID: 42},
Message: models.MaybeInaccessibleMessage{Message: message},
}, releaseupdate.Snapshot{})
last := (*requests)[len(*requests)-1]
text := strings.ToLower(last.form["text"])
if !strings.Contains(text, "failed") {
t.Errorf("summary missing failure notice: %q", text)
}
if strings.Contains(text, "restart queued") {
t.Errorf("summary falsely claims a restart was queued: %q", text)
}
}
// TestReportPendingUpdateSendsAndClearsReport: this is the phase-2 side of
// the two-phase update report -- called on every gateway launch (process
// boot and /restart alike), it must relay whatever the update watchdog
// decided and never report the same outcome twice.
func TestReportPendingUpdateSendsAndClearsReport(t *testing.T) {
path := filepath.Join(t.TempDir(), "update-report.json")
report := releaseupdate.Report{
Channel: "telegram", ChatID: 7, ThreadID: 3,
Previous: map[string]string{releaseupdate.ComponentDaemon: "1.0.0"}, Installed: map[string]string{releaseupdate.ComponentDaemon: "1.1.0"},
HealthCheck: "passed",
}
if err := releaseupdate.WritePendingReport(path, report); err != nil {
t.Fatal(err)
}
g := New("1:test", []int64{42}, slog.Default())
g.UpdateReportPath = path
b, requests := newTelegramTestBot(t)
g.reportPendingUpdate(context.Background(), b)
if len(*requests) != 1 {
t.Fatalf("requests = %#v, want exactly one", *requests)
}
if got := (*requests)[0].form["chat_id"]; got != "7" {
t.Errorf("chat_id = %q, want 7", got)
}
if _, found, err := releaseupdate.ReadPendingReport(path); err != nil || found {
t.Errorf("report still present after reportPendingUpdate: found=%v err=%v", found, err)
}
}
// TestReportPendingUpdateClearsUnreadableReport: a corrupt report file
// (partial write, disk issue, a future format the running binary doesn't
// understand) must not jam forever -- without clearing it, every future
// launch would retry, fail identically, and the chat that approved the
// update would never learn any outcome at all.
func TestReportPendingUpdateClearsUnreadableReport(t *testing.T) {
path := filepath.Join(t.TempDir(), "update-report.json")
if err := os.WriteFile(path, []byte("{not valid json"), 0o600); err != nil {
t.Fatal(err)
}
g := New("1:test", []int64{42}, slog.Default())
g.UpdateReportPath = path
b, _ := newTelegramTestBot(t)
g.reportPendingUpdate(context.Background(), b)
if _, err := os.Stat(path); !os.IsNotExist(err) {
t.Fatalf("corrupt report file still exists after reportPendingUpdate: err = %v", err)
}
}
func TestReportPendingUpdateNoFileIsNoop(t *testing.T) {
g := New("1:test", []int64{42}, slog.Default())
g.UpdateReportPath = filepath.Join(t.TempDir(), "does-not-exist.json")
b, requests := newTelegramTestBot(t)
g.reportPendingUpdate(context.Background(), b)
if len(*requests) != 0 {
t.Fatalf("requests = %#v, want none", *requests)
}
}
func TestReportPendingUpdateDisabledWhenPathEmpty(t *testing.T) {
g := New("1:test", []int64{42}, slog.Default())
b, requests := newTelegramTestBot(t)
g.reportPendingUpdate(context.Background(), b)
if len(*requests) != 0 {
t.Fatalf("requests = %#v, want none", *requests)
}
}
// TestFormatPendingReportVerifiesAgainstRunningVersions is the regression
// suite for the false-success bug: the watchdog's health probe passes
// whenever *a* daemon answers it, so a report can claim an install that never
// took effect. A claim the running system contradicts must not be worded as
// success; a claim it cannot check must still be, since failing closed on
// components that simply cannot self-report would call every update a
// failure.
func TestFormatPendingReportVerifiesAgainstRunningVersions(t *testing.T) {
const (
daemon = releaseupdate.ComponentDaemon
agent = releaseupdate.ComponentAgent
previousVer = "1.0.0"
installedVer = "1.1.0"
)
tests := []struct {
name string
previous map[string]string
installed map[string]string
running map[string]string
wantText []string
denyText []string
}{
{
name: "running the version the update replaced",
previous: map[string]string{daemon: previousVer},
installed: map[string]string{daemon: installedVer},
running: map[string]string{daemon: previousVer},
wantText: []string{daemon, previousVer, installedVer, "still the version this update meant to replace"},
denyText: []string{"update complete", "healthy on the new version"},
},
{
name: "running a version the report never mentions",
previous: map[string]string{daemon: previousVer},
installed: map[string]string{daemon: installedVer},
running: map[string]string{daemon: "9.9.9"},
wantText: []string{daemon, "9.9.9", installedVer},
denyText: []string{"update complete", "still the version this update meant to replace"},
},
{
// A single sentence covering all components cannot be true of a
// mixed set: the daemon here IS on the version the update meant
// to replace and the agent is on neither, so the explanation has
// to attach per component or it states a falsehood about one of
// them. The trailing semicolon in the agent assertion is what
// proves the annotation did not leak onto it.
name: "mixed drift annotates each component separately",
previous: map[string]string{daemon: previousVer, agent: previousVer},
installed: map[string]string{daemon: installedVer, agent: installedVer},
running: map[string]string{daemon: previousVer, agent: "9.9.9"},
wantText: []string{
"agent reports 9.9.9, not the installed " + installedVer + ";",
"daemon reports " + previousVer + ", not the installed " + installedVer +
" (still the version this update meant to replace)",
},
denyText: []string{"update complete"},
},
{
name: "claim confirmed by the running version",
previous: map[string]string{daemon: previousVer},
installed: map[string]string{daemon: installedVer},
running: map[string]string{daemon: installedVer},
wantText: []string{"update complete"},
denyText: []string{"did not take effect"},
},
{
// The ordinary production shape: only the daemon can self-report,
// so a successful update always confirms the daemon and leaves
// the agent unchecked. The headline is earned, but the version
// line above it covers the agent too, so the message has to say
// which components nothing actually verified -- otherwise the
// confirmed daemon silently vouches for the agent.
name: "component that cannot self-report is named, not treated as drift",
previous: map[string]string{daemon: previousVer, agent: previousVer},
installed: map[string]string{daemon: installedVer, agent: installedVer},
running: map[string]string{daemon: installedVer},
wantText: []string{"update complete", "not independently checked: " + agent},
denyText: []string{"did not take effect"},
},
{
name: "nothing is left unchecked when every component confirms",
previous: map[string]string{daemon: previousVer},
installed: map[string]string{daemon: installedVer},
running: map[string]string{daemon: installedVer},
wantText: []string{"healthy on the new version"},
denyText: []string{"not independently checked"},
},
{
name: "nothing self-reports, so success is reported unconfirmed",
previous: map[string]string{daemon: previousVer},
installed: map[string]string{daemon: installedVer},
running: nil,
wantText: []string{"can't confirm which version"},
denyText: []string{"did not take effect", "healthy on the new version"},
},
{
name: "an unrecorded claim is not a contradiction, but is not confirmed either",
previous: map[string]string{daemon: previousVer},
installed: map[string]string{daemon: releaseupdate.VersionUnknown},
running: map[string]string{daemon: installedVer},
wantText: []string{"can't confirm which version"},
denyText: []string{"did not take effect", "healthy on the new version", releaseupdate.VersionUnknown},
},
{
name: "an unstamped running build cannot confirm or contradict",
previous: map[string]string{daemon: previousVer},
installed: map[string]string{daemon: installedVer},
running: map[string]string{daemon: releaseupdate.VersionDev},
wantText: []string{"can't confirm which version"},
denyText: []string{"did not take effect", "healthy on the new version"},
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
report := releaseupdate.Report{
Previous: test.previous,
Installed: test.installed,
HealthCheck: "passed",
}
text := formatPendingReport(report, test.running)
lower := strings.ToLower(text)
for _, want := range test.wantText {
if !strings.Contains(lower, strings.ToLower(want)) {
t.Errorf("report does not mention %q: %q", want, text)
}
}
for _, deny := range test.denyText {
if strings.Contains(lower, strings.ToLower(deny)) {
t.Errorf("report wrongly claims %q: %q", deny, text)
}
}
})
}
}
func TestFormatPendingReportDescribesSuccessAndRollback(t *testing.T) {
success := releaseupdate.Report{
Previous: map[string]string{releaseupdate.ComponentDaemon: "1.0.0"},
Installed: map[string]string{releaseupdate.ComponentDaemon: "1.1.0"},
HealthCheck: "passed",
RolledBack: false,
}
text := formatPendingReport(success, map[string]string{releaseupdate.ComponentDaemon: "1.1.0"})
for _, want := range []string{"1.0.0 → 1.1.0", "healthy"} {
if !strings.Contains(strings.ToLower(text), strings.ToLower(want)) {
t.Errorf("success report missing %q: %q", want, text)
}
}
failure := releaseupdate.Report{
Previous: map[string]string{releaseupdate.ComponentDaemon: "1.0.0"},
Installed: map[string]string{releaseupdate.ComponentDaemon: "1.1.0"},
HealthCheck: "failed",
RolledBack: true,
}
text = formatPendingReport(failure, map[string]string{releaseupdate.ComponentDaemon: "1.0.0"})
for _, want := range []string{"rolled back", "1.0.0"} {
if !strings.Contains(strings.ToLower(text), strings.ToLower(want)) {
t.Errorf("rollback report missing %q: %q", want, text)
}
}
}
// TestFormatPendingReportDistinguishesUnrolledBackFailure: a failed health
// check with no backup to restore from must never read like the success or
// rolled-back cases -- the daemon may still be running the broken version,
// or may not be running at all, and nothing further will fix that
// automatically. Reporting this the same as a successful rollback is worse
// than reporting nothing, because it tells the operator to stand down.
func TestFormatPendingReportDistinguishesUnrolledBackFailure(t *testing.T) {
notRolledBack := releaseupdate.Report{
Previous: map[string]string{releaseupdate.ComponentDaemon: "1.0.0"},
Installed: map[string]string{releaseupdate.ComponentDaemon: "1.1.0"},
HealthCheck: "failed",
RolledBack: false,
}
text := strings.ToLower(formatPendingReport(notRolledBack, map[string]string{releaseupdate.ComponentDaemon: "1.1.0"}))
if strings.Contains(text, "was automatically rolled back") {
t.Errorf("report falsely claims a rollback happened: %q", text)
}
if strings.Contains(text, "running normally") {
t.Errorf("report falsely claims the system is healthy: %q", text)
}
for _, want := range []string{"could not", "manual"} {
if !strings.Contains(text, want) {
t.Errorf("report missing %q (must call out that manual intervention is needed): %q", want, text)
}
}
}
func TestUpdateCallbackRejectsUnauthorizedSender(t *testing.T) {
g := New("1:test", []int64{42}, slog.Default())
g.Updates = &updateStub{}
b, requests := newTelegramTestBot(t)
g.handleUpdateCallback(context.Background(), b, &models.Update{CallbackQuery: &models.CallbackQuery{
ID: "callback", From: models.User{ID: 99}, Data: updateApproveCallback,
}})
stub, ok := g.Updates.(*updateStub)
if !ok {
t.Fatalf("g.Updates is %T, want *updateStub", g.Updates)
}
if stub.installCalls != 0 {
t.Error("unauthorized callback started an installation")
}
if len(*requests) != 1 || (*requests)[0].method != "answerCallbackQuery" {
t.Fatalf("requests = %#v, want authorization response", *requests)
}
}
type updateStub struct {
snapshot releaseupdate.Snapshot
installCalls int
gotMeta releaseupdate.InstallMeta
result releaseupdate.Result
installErr error
progressText []string
}
func (s *updateStub) Check(context.Context, int64) (releaseupdate.Snapshot, error) {
return s.snapshot, nil
}
func (s *updateStub) Defer(context.Context, int64, releaseupdate.Snapshot) error { return nil }
func (s *updateStub) Install(_ context.Context, _ releaseupdate.Snapshot, meta releaseupdate.InstallMeta, progress func(string)) (releaseupdate.Result, error) {
s.installCalls++
s.gotMeta = meta
for _, line := range s.progressText {
progress(line)
}
if s.installErr != nil {
return releaseupdate.Result{}, s.installErr
}
return s.result, nil
}
func (*updateStub) CanInstall() bool { return true }