Files
mesh-catalog/modules/messenger/cmd/messenger/held_test.go
T
jschoubben 59704456c3 messenger: offer every ask when it is raised; hold none back for room
The operator channel kept at most three asks of one asker offered and held its oldest back behind newer ones, so asks
waited unseen (the pipeline's proposal behind two mailu asks). It keeps no count any more and holds nothing back: every
ask is offered when it is raised, and lapses at its expiry or ends at its answer. An ask held back before the change is
offered again at the router's next tick; ask-again offers one so and holds nothing back in its place.

Builds: design 47 G A-424
2026-11-15 15:52:48 +01:00

196 lines
8.2 KiB
Go

package main
import (
"encoding/json"
"reflect"
"strings"
"testing"
"time"
occ "git.novox.be/novox/mesh-contracts/operator-and-conversation/go/clients/operatorchannelclient"
)
// A held ask (novox/hq ADR 0397, issue 926): an ask that breaks no rule but that no ready channel can carry now
// is kept, not refused, and offered the moment a channel can carry it.
// withoutVerifiedSender is the controller's word on the kinds when Telegram's claim lacks verified-sender, as
// on 2026-10-16 (issue 930).
func withoutVerifiedSender(h *Holder) {
h.Bench.SetKinds([]KindInfo{
{Kind: "telegram", Module: "telegram", Node: "anchor", Capabilities: []string{"deliver", "reaches-away", "choice", "edit", "exact-render"}},
{Kind: "desktop", Module: "desk-channel", Node: "anchor", Capabilities: []string{"deliver", "choice", "edit", "exact-render", "private"}},
})
}
func withVerifiedSender(h *Holder) {
h.Bench.SetKinds([]KindInfo{
{Kind: "telegram", Module: "telegram", Node: "anchor", Capabilities: []string{"deliver", "reaches-away", "choice", "edit", "verified-sender", "exact-render"}},
{Kind: "desktop", Module: "desk-channel", Node: "anchor", Capabilities: []string{"deliver", "choice", "edit", "exact-render", "private"}},
})
}
func recordJSON(t *testing.T, store *memAsks, key string) string {
t.Helper()
raw, _ := json.Marshal(store.asks[key])
return string(raw)
}
func TestAnApprovalAskNoChannelCanCarryIsHeldAndItsAskerToldWhy(t *testing.T) {
h, tg, dt, c, store, w := newRouter(t)
link(h, store, c, "42", c.now().Add(-2*time.Hour))
withoutVerifiedSender(h)
submit(t, h, "mesh-delivery", heldAsk(c, "d-1"))
settle(h, c)
for _, g := range w.of("mesh-delivery") {
t.Errorf("the asker was told it ended: %+v", g)
}
rec, kept := store.asks["mesh-delivery.d-1"]
if !kept || rec.State != StateHeld || len(rec.Tickets) != 0 {
t.Fatalf("not held: %+v", rec)
}
for _, want := range []string{"Telegram cannot prove who answered", "held"} {
if !strings.Contains(recordJSON(t, store, "mesh-delivery.d-1"), want) {
t.Errorf("the record does not say %q: %s", want, recordJSON(t, store, "mesh-delivery.d-1"))
}
}
if strings.Contains(rec.HeldWhy, "no channel") && !strings.Contains(rec.HeldWhy, "Telegram") {
t.Errorf("only no channel: %q", rec.HeldWhy)
}
if len(tg.sends) != 0 || len(dt.sends) != 0 {
t.Errorf("a held ask was shown: %d %d", len(tg.sends), len(dt.sends))
}
}
func TestAHeldAskIsOfferedWhenTheKindsChange(t *testing.T) {
h, tg, _, c, store, w := newRouter(t)
link(h, store, c, "42", c.now().Add(-2*time.Hour))
withoutVerifiedSender(h)
submit(t, h, "mesh-delivery", heldAsk(c, "d-1"))
c.pass(time.Minute)
stand(h, c)
h.Tick() // still held: the reason is unchanged
if rec := store.asks["mesh-delivery.d-1"]; rec.State != StateHeld || len(tg.sends) != 0 {
t.Fatalf("offered too soon: %+v", rec)
}
withVerifiedSender(h)
h.Tick()
settle(h, c)
rec := store.asks["mesh-delivery.d-1"]
if rec.State != StateOpen || len(rec.Tickets) != 3 || rec.HeldWhy != "" {
t.Fatalf("not offered: %+v", rec)
}
if len(tg.sends) != 1 || labelsOf(tg.sends[0]) != "Release, Stop, Silence for a week" {
t.Fatalf("telegram was sent %+v", tg.sends)
}
if got := w.of("mesh-delivery"); len(got) != 0 {
t.Errorf("an offer is not an end: %+v", got)
}
// Answered as any ask is.
out, err := h.Chosen("telegram", choiceOf(ticketFor(tg.sends[0], "Release"), "42", c.now()))
if err != nil || out != "chosen" {
t.Fatalf("%s %v", out, err)
}
}
func TestAHeldAskExpiresAsAnyOpenAskDoes(t *testing.T) {
h, _, _, c, store, w := newRouter(t)
withoutVerifiedSender(h)
submit(t, h, "mesh-delivery", heldAsk(c, "d-1"))
c.pass(3 * time.Hour)
stand(h, c)
h.Tick()
got := w.of("mesh-delivery")
if len(got) != 1 || got[0].Outcome != occ.OutcomeExpired || store.asks["mesh-delivery.d-1"].State != string(occ.OutcomeExpired) {
t.Fatalf("%+v %+v", got, store.asks["mesh-delivery.d-1"])
}
}
// Design 47 G A-424: four held asks of one asker are taken and held for want of a channel, and none is held back for room.
func TestFourHeldAsksOfOneAskerAreHeldAndNoneHeldBack(t *testing.T) {
h, _, _, c, store, w := newRouter(t)
withoutVerifiedSender(h)
for i := 1; i <= 4; i++ {
a := heldAsk(c, "d-"+string(rune('0'+i)))
a.About = "about-" + string(rune('0'+i))
submit(t, h, "mesh-delivery", a)
c.pass(time.Second)
}
if got := w.of("mesh-delivery"); len(got) != 0 || store.asks["mesh-delivery.d-1"].State != StateHeld || store.asks["mesh-delivery.d-4"].State != StateHeld {
t.Fatalf("%+v: a fourth is taken, never refused, and none is held back (d-1 %s)", got, store.asks["mesh-delivery.d-1"].State)
}
}
func TestTheAsksVerbShowsAHeldAskWithSinceAndWhy(t *testing.T) {
h, _, _, c, _, _ := newRouter(t)
withoutVerifiedSender(h)
submit(t, h, "mesh-delivery", heldAsk(c, "d-1"))
raw, _ := json.Marshal(h.AsksNow())
for _, want := range []string{`"state":"held"`, `"held_since"`, `"held_why":"`, "Telegram cannot prove who answered"} {
if !strings.Contains(string(raw), want) {
t.Errorf("the asks verb lacks %q: %s", want, raw)
}
}
}
func TestAHeldAskNamesEveryKindAndWhyWhenNoChannelIsReady(t *testing.T) {
h, _, _, c, store, _ := newRouter(t)
h.Bench.Stand("telegram", Standing{Ready: false, Why: "no bot token", At: c.now()})
h.Bench.Stand("desktop", Standing{Ready: false, Why: "no session", At: c.now()})
submit(t, h, "mesh-delivery", heldAsk(c, "d-1"))
why := store.asks["mesh-delivery.d-1"].HeldWhy
if store.asks["mesh-delivery.d-1"].State != StateHeld || !strings.Contains(why, "Telegram: no bot token") || !strings.Contains(why, "the desk: no session") {
t.Fatalf("%q", why)
}
}
// Issue 595: operator-channel.asks answers one ask, the open or the ended, those opened from a time, and no more bytes than a
// bound, said when it cut the answer short; with no argument it answers the open asks only, within a default bound, and says so (issue 1974).
func TestTheAsksVerbNarrowsItsAnswer(t *testing.T) {
view := func(key, state, opened string) AskView {
return AskView{Key: key, Asker: "mesh-delivery", Headline: "Approve " + key, State: state, Opened: opened}
}
all := []AskView{view("a.3", StateOpen, "2026-11-04T10:00:00Z"), view("a.2", StateHeld, "2026-11-03T10:00:00Z"),
view("a.1", "ended", "2026-11-02T10:00:00Z"), view("a.0", "ended", "2026-11-01T10:00:00Z")}
one, _ := json.Marshal(all[0])
for _, tc := range []struct {
name string
args map[string]any
want []string
matched int
cut bool
err bool
}{
{"no argument is the open asks, said", map[string]any{}, []string{"a.3", "a.2"}, 2, false, false},
{"state all is every ask", map[string]any{"state": "all"}, []string{"a.3", "a.2", "a.1", "a.0"}, 4, false, false},
{"a key finds an ended ask whatever its state", map[string]any{"key": "a.0"}, []string{"a.0"}, 1, false, false},
{"key", map[string]any{"key": "a.1"}, []string{"a.1"}, 1, false, false},
{"state open takes open and held", map[string]any{"state": "open"}, []string{"a.3", "a.2"}, 2, false, false},
{"state ended", map[string]any{"state": "ended"}, []string{"a.1", "a.0"}, 2, false, false},
{"since", map[string]any{"since": "2026-11-02T12:00:00Z"}, []string{"a.3", "a.2"}, 2, false, false},
{"bound cuts and says so", map[string]any{"bound": float64(2*len(one) + 10), "state": "open"}, []string{"a.3", "a.2"}, 2, false, false},
{"a bound under the asks cuts", map[string]any{"bound": float64(len(one) + 5)}, []string{"a.3"}, 2, true, false},
{"a state that is neither", map[string]any{"state": "done"}, nil, 0, false, true},
{"a time that is not one", map[string]any{"since": "yesterday"}, nil, 0, false, true},
} {
q, err := AsksQueryOf(tc.args)
if (err != nil) != tc.err {
t.Errorf("%s: err = %v", tc.name, err)
continue
}
if tc.err {
continue
}
got := q.Narrow(all)
if (got.Default != "") != (tc.args["key"] == nil && tc.args["state"] == nil && tc.args["since"] == nil) || q.Bound == 0 {
t.Errorf("%s: default %q, bound %d: only no argument is defaulted, and every query is bounded", tc.name, got.Default, q.Bound)
}
var keys []string
for _, v := range got.Asks {
keys = append(keys, v.Key)
}
if !reflect.DeepEqual(keys, tc.want) || got.Matched != tc.matched || (got.Cut != "") != tc.cut {
t.Errorf("%s: asks %v matched %d cut %q, want %v, %d, cut %v", tc.name, keys, got.Matched, got.Cut, tc.want, tc.matched, tc.cut)
}
}
}