From 82d7bb301de8712040d396112f2555de5c39a092 Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Tue, 15 Sep 2026 12:48:51 +1000 Subject: [PATCH 1/3] test(telegram): pin upload-ceiling agreement with send_file Choice: cross-package test (pin). Both ceiling pairs are live producers and currently agree, so the WIRE/DELETE rule does not apply. Deriving one shared definition would either require a new package outside this lane's ownership or bind the channel-free sendfile tool to the telegram package; the cross-package test pins the documented 'the two must agree' contract at the duplicate itself. --- internal/channels/telegram/media_test.go | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/internal/channels/telegram/media_test.go b/internal/channels/telegram/media_test.go index b3c6b9bde..8edd297d2 100644 --- a/internal/channels/telegram/media_test.go +++ b/internal/channels/telegram/media_test.go @@ -16,6 +16,7 @@ import ( "github.com/go-telegram/bot" "github.com/samcharles93/archie-core/internal/gateway" + "github.com/samcharles93/archie-core/internal/tools/sendfile" ) // mediaAPI stands in for the Bot API, recording which sendX method was @@ -450,6 +451,22 @@ func TestSendMedia_LocalPathFailures(t *testing.T) { } } +// TestMediaUploadCeilingsAgreeWithSendFile pins the contract documented in +// sendfile/tool.go: the send_file early check and this sender's Bot API +// ceilings must be the same number, or an oversized file is reported "sent" +// by the tool and then silently rejected here -- the exact silent +// non-delivery send_file exists to end. +func TestMediaUploadCeilingsAgreeWithSendFile(t *testing.T) { + if sendfile.MaxImageUploadBytes != maxPhotoUploadBytes { + t.Errorf("send_file image ceiling = %d bytes, telegram photo ceiling = %d bytes; they must agree", + sendfile.MaxImageUploadBytes, maxPhotoUploadBytes) + } + if sendfile.MaxUploadBytes != maxFileUploadBytes { + t.Errorf("send_file upload ceiling = %d bytes, telegram file ceiling = %d bytes; they must agree", + sendfile.MaxUploadBytes, maxFileUploadBytes) + } +} + // A photo just under the photo ceiling must still be accepted -- the // per-type limits must not collapse into one conservative number. func TestSendMedia_PhotoUnderLimitIsSent(t *testing.T) { From a85ba428701b93eb66ac0e80440162b6328b88a5 Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Tue, 15 Sep 2026 12:51:17 +1000 Subject: [PATCH 2/3] fix(servicediscovery/nats): validate config after defaults Root-cause fix: Connect validated the raw config before withDefaults, so the Heartbeat= TTL). +func TestConnectRejectsTTLBelowDefaultHeartbeat(t *testing.T) { + _, err := Connect(context.Background(), Config{URL: "nats://127.0.0.1:1", TTL: 2 * time.Second}, discardLogger()) + if !errors.Is(err, ErrInvalidConfig) { + t.Fatalf("Connect() = %v, want ErrInvalidConfig", err) + } +} + // newServer starts a real in-process NATS server with JetStream enabled. This // is the established test technique for the NATS infrastructure (see the // sibling eventbus/nats retention test): a real server, not a mocked client. From 9745ab9661d38700d9655e6d980066c5275041a6 Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Tue, 15 Sep 2026 12:53:25 +1000 Subject: [PATCH 3/3] fix(releaseupdate): don't treat empty available as deferred Service.Check matched deferred[component.ID] == component.Available, and a never-deferred recipient's absent entry is the empty string -- equal to an empty Available emitted for a component with no update. Guard on a real (non-empty) available version before applying the deferral, so an up-to-date recipient is not told their update is deferred. No WIRE/DELETE decision applies: this is a correctness fix on a live consumer, not unreachable code. --- internal/releaseupdate/service.go | 2 +- internal/releaseupdate/service_test.go | 24 ++++++++++++++++++++++++ 2 files changed, 25 insertions(+), 1 deletion(-) diff --git a/internal/releaseupdate/service.go b/internal/releaseupdate/service.go index c48effffd..48b2b453d 100644 --- a/internal/releaseupdate/service.go +++ b/internal/releaseupdate/service.go @@ -147,7 +147,7 @@ func (s *Service) Check(ctx context.Context, recipient int64) (Snapshot, error) deferred := state[strconv.FormatInt(recipient, 10)] for index := range snapshot.Components { component := &snapshot.Components[index] - if deferred[component.ID] == component.Available { + if component.Available != "" && deferred[component.ID] == component.Available { component.Available = "" snapshot.Deferred = true } diff --git a/internal/releaseupdate/service_test.go b/internal/releaseupdate/service_test.go index c56332b4e..28604291a 100644 --- a/internal/releaseupdate/service_test.go +++ b/internal/releaseupdate/service_test.go @@ -50,6 +50,30 @@ func TestServiceDefersOnlyTheVersionsShownToThatRecipient(t *testing.T) { } } +// TestServiceCheckNeverDeferredEmptyAvailable pins the empty-Available +// combination: for a recipient who has never deferred a component (or a +// component absent from the deferral map), deferred[component.ID] is the +// empty string, and a component with no available update also has an empty +// Available. "" == "" must not read as a deferral -- that tells an +// up-to-date recipient their update is "deferred". +func TestServiceCheckNeverDeferredEmptyAvailable(t *testing.T) { + catalog := &catalogStub{snapshot: Snapshot{Components: []Component{ + {ID: ComponentDaemon, Label: "Gateway", Installed: "1.0.0", Available: ""}, + }}} + service := Service{Catalog: catalog, StatePath: filepath.Join(t.TempDir(), "deferrals.json")} + + snapshot, err := service.Check(context.Background(), 42) + if err != nil { + t.Fatal(err) + } + if snapshot.Deferred { + t.Error("Deferred = true for a never-deferred recipient with no available update") + } + if got := snapshot.Components[0].Available; got != "" { + t.Errorf("Available = %q, want empty", got) + } +} + // TestServiceCheckEnrichesInstallTypeAndReference is the regression proof // for archie-core-1786751948782-3-837a8fd0 point 4: the external check // command reports what version exists, not how this instance was actually