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.
423 lines
17 KiB
Go
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 }
|