Files
mesh-catalog/modules/mesh-knowledge/cmd/mesh-knowledge/progress_test.go
T
jschoubben df79ab8769 mesh-knowledge: the overview's delivery block and the progress verb's groups lines go
Review round 1, Must 3: the groups and group-ended are retired; the overview
showed the deliveries, another module's state, which the status view owns.
The overview keeps two sources (the tracker, the asks), consumes no merge,
transition or pipeline's end, and the progress verb asks no groups.

Builds: design 47 H §764 (the gate's verb groups; the runner's group-ended); H-A-28; H-A-125

Claude-Session: https://claude.ai/code/session_01JG73KHUnBze48rdua8u2sy
2026-11-20 06:04:16 +01:00

570 lines
24 KiB
Go

package main
import (
"encoding/json"
"errors"
"fmt"
"os"
"path/filepath"
"reflect"
"strings"
"sync"
"testing"
"time"
)
// The progress verb's tests (novox/hq issue 1947). The designs are hq's, captured at a commit; the tracker's rows and
// the delivery seat's answers were captured from the live mesh on 2026-10-26 (testdata/progress/README.md).
func progressRecords() dirRecords {
return dirRecords{dir: filepath.Join("testdata", "progress", "hq")}
}
// withDesigns is the fixture's records with the captured designs beside them, as the bus test's records module
// serves them: a folder or document the first does not hold is read from the second.
type withDesigns struct{ base, designs dirRecords }
func (w withDesigns) Standing() (string, error) { return w.base.Standing() }
func (w withDesigns) List(folder string) ([]string, []string, error) {
if f, d, err := w.base.List(folder); err == nil {
return f, d, nil
}
return w.designs.List(folder)
}
func (w withDesigns) Read(path string) (string, string, error) {
if c, commit, err := w.base.Read(path); err == nil {
return c, commit, nil
}
c, _, err := w.designs.Read(path)
commit, _ := w.base.Standing()
return c, commit, err
}
func (w withDesigns) ReadHead(path string, n int) (string, string, error) {
if c, commit, err := w.base.ReadHead(path, n); err == nil {
return c, commit, nil
}
c, _, err := w.designs.ReadHead(path, n)
commit, _ := w.base.Standing()
return c, commit, err
}
// seatsWorld plays the issue tracker and mesh-delivery from the captured answers, and counts what it is asked.
type seatsWorld struct {
mu sync.Mutex
rows map[int]json.RawMessage
linked map[string][]int
// milestones is the tracker's milestone records (issue 1781).
milestones json.RawMessage
asked map[string]int
files map[string]json.RawMessage
}
func newSeatsWorld(t *testing.T) *seatsWorld {
t.Helper()
s := &seatsWorld{rows: map[int]json.RawMessage{}, linked: map[string][]int{}, asked: map[string]int{}, files: map[string]json.RawMessage{}}
var rows []json.RawMessage
if err := json.Unmarshal(readFixture(t, "tracker-rows.json"), &rows); err != nil {
t.Fatal(err)
}
for _, r := range rows {
var n struct{ Number int }
_ = json.Unmarshal(r, &n)
s.rows[n.Number] = r
}
s.milestones = readFixture(t, "tracker-milestones-47.json")
for _, f := range []string{"deliveries.json", "show-car-hunter-2.json"} {
s.files[f] = readFixture(t, f)
}
return s
}
func readFixture(t *testing.T, name string) json.RawMessage {
t.Helper()
raw, err := os.ReadFile(filepath.Join("testdata", "progress", name))
if err != nil {
t.Fatal(err)
}
return raw
}
func (s *seatsWorld) ask(key string, body any) (json.RawMessage, error) {
s.mu.Lock()
defer s.mu.Unlock()
s.asked[key]++
raw, _ := json.Marshal(body)
var a struct {
Numbers []int `json:"numbers"`
Linked string `json:"linked"`
Number int `json:"number"`
ID string `json:"id"`
Design int `json:"design"`
}
_ = json.Unmarshal(raw, &a)
switch key {
case MilestonesVerb:
if a.Design != 0 && a.Design != 47 {
return json.RawMessage(`{"milestones": []}`), nil
}
return s.milestones, nil
case "seat:issue-tracker.list":
numbers := a.Numbers
if a.Linked != "" {
numbers = s.linked[a.Linked]
}
var rows []json.RawMessage
for _, n := range numbers {
if r, ok := s.rows[n]; ok {
rows = append(rows, r)
}
}
return json.Marshal(map[string]any{"rows": rows, "matched": len(rows)})
case "seat:issue-tracker.get":
return json.Marshal(map[string]any{"number": a.Number, "notes": []map[string]any{{"at": "2026-10-26T15:12:15Z", "by": "shanks.node-tools", "text": "a note"}},
"notes-left-out": 96, "links": []map[string]any{{"kind": "depends-on", "target": "1943"}}})
case "seat:mesh-delivery.deliveries":
return s.files["deliveries.json"], nil
case "seat:mesh-delivery.show":
if a.ID == "jschoubben/car-hunter@cc4c8ce12901" {
return s.files["show-car-hunter-2.json"], nil
}
return json.RawMessage(`{"delivery": {}}`), nil
}
return nil, os.ErrNotExist
}
// countingRecords is Records that counts the documents read and can be moved to another commit.
type countingRecords struct {
dirRecords
commit string
reads int
}
func (c *countingRecords) Standing() (string, error) { return c.commit, nil }
func (c *countingRecords) Read(p string) (string, string, error) {
c.reads++
content, _, err := c.dirRecords.Read(p)
return content, c.commit, err
}
func (c *countingRecords) ReadHead(p string, n int) (string, string, error) {
c.reads++
content, _, err := c.dirRecords.ReadHead(p, n)
return content, c.commit, err
}
// brokenRead is Records whose reads fail as the records module's do for a document longer than it answers whole.
type brokenRead struct{ dirRecords }
func (brokenRead) ReadHead(p string, n int) (string, string, error) {
return "", "", fmt.Errorf("%s is longer than the records module answers whole", p)
}
// 1947/AC2, as issue 1781 changed it: a design's title, state and decisions are hq's; its milestones are the issue
// tracker's records, ordered as its table, an id found with spaces or hyphens, and a closed one holding no issue done.
func TestADesignsMilestonesAreTheTrackersRecords(t *testing.T) {
content, _, err := progressRecords().Read(DesignsFolder + "/47-delivery-from-commit-to-delivered.md")
if err != nil {
t.Fatal(err)
}
d := parseDesign(DesignsFolder+"/47-delivery-from-commit-to-delivered.md", content)
if d.Number != 47 || d.Title != "Delivery: from a commit to delivered" || d.Status != "in-progress" || !contains(d.Decisions, "ADR 0276") ||
len(d.Milestones) != 0 {
t.Fatalf("design %d %q %q %v, %d milestones read from hq", d.Number, d.Title, d.Status, d.Decisions, len(d.Milestones))
}
seats := newSeatsWorld(t)
k := &KB{Seats: seats.ask}
ds, err := k.withMilestones([]*Design{d}, 47)
if err != nil {
t.Fatal(err)
}
if len(ds[0].Milestones) != 29 || len(d.Milestones) != 0 || seats.asked[MilestonesVerb] != 1 {
t.Fatalf("%d milestones; the cached design holds %d", len(ds[0].Milestones), len(d.Milestones))
}
for _, c := range []struct {
id string
want []int
}{
{"1", []int{973, 525}},
{"R6", []int{1942, 1945, 1943, 1944, 1946, 1906, 1130}},
{"r4d", []int{}},
{"3 fix", []int{1082, 1049, 1047, 1083, 1079, 1084}},
} {
m := ds[0].milestone(c.id)
if m == nil {
t.Fatalf("no milestone %s", c.id)
}
if !reflect.DeepEqual(m.Issues, c.want) {
t.Errorf("milestone %s: %v, want %v", c.id, m.Issues, c.want)
}
}
closed := &Design{Milestones: []Milestone{{ID: "6", Status: "closed", Reason: "folded into release 4"}, {ID: "R4d", Status: "open"}}}
items, _ := milestoneItems(closed, nil, nil)
if items[0].State != StateDone || items[1].State != StateWaiting {
t.Fatalf("%+v", items)
}
}
// 1947/AC6: the designs are read once per commit of hq, and again when it moves; the mesh level names those with
// milestones one by one and counts the rest.
func TestDesignsAreReadAgainOnlyWhenHqMoves(t *testing.T) {
rec := &countingRecords{dirRecords: progressRecords(), commit: "aaaa"}
seats := newSeatsWorld(t)
k := &KB{Records: rec, Seats: seats.ask, Now: func() time.Time { return time.Date(2026, 10, 26, 15, 30, 0, 0, time.UTC) }}
p, err := k.Progress(ProgressAsk{Of: "mesh"})
if err != nil {
t.Fatal(err)
}
if rec.reads != 3 {
t.Fatalf("read %d documents for the mesh, want 3", rec.reads)
}
if !strings.Contains(p.Tree, "3 designs in progress, 1 with milestones") || !strings.Contains(p.Tree, "design 47 · Delivery: from a commit to delivered") ||
!strings.Contains(p.Tree, "2 designs in progress name no milestones (issue 845): 53, 57") {
t.Fatalf("mesh:\n%s", p.Tree)
}
for range 2 {
if _, err := k.Progress(ProgressAsk{Of: "design 47"}); err != nil {
t.Fatal(err)
}
}
if rec.reads != 3 {
t.Fatalf("read %d documents with hq standing still, want 3", rec.reads)
}
rec.commit = "bbbb"
if _, err := k.Progress(ProgressAsk{Of: "design 47"}); err != nil {
t.Fatal(err)
}
if rec.reads != 4 {
t.Fatalf("read %d documents after hq moved, want 4", rec.reads)
}
if _, err := k.Progress(ProgressAsk{Of: "design 99"}); err == nil || !strings.Contains(err.Error(), "no design 99") {
t.Fatalf("an unknown design: %v", err)
}
}
// 1947/AC3: an issue's state from its tracker row, and a parent's from its children.
func TestIssueStatesAndTheirRollUp(t *testing.T) {
seats := newSeatsWorld(t)
row := func(n int) trackerRow {
var r trackerRow
if err := json.Unmarshal(seats.rows[n], &r); err != nil {
t.Fatal(err)
}
return r
}
for _, c := range []struct {
n int
state string
why string
counts bool
}{
{1942, StateDone, "resolved, delivered", true},
{1943, StateDone, "resolved, nothing to deliver", true},
{1946, StateMoving, "resolved · fix merged, not delivered: mesh-catalog#475", true},
{1906, StateStuck, "resolved · held: mesh-delivery#39", true},
{1945, StateMoving, "fixing since", true},
{1049, StateStuck, "worker fix-chain-cat@shanks stale since", true},
{1126, StateWaiting, "open, needs a decision", true},
{774, StateWaiting, "open, ready", true},
{1021, "", "", false},
} {
it, counts := issueItem(row(c.n))
if counts != c.counts || it.State != c.state || !strings.Contains(it.Why, c.why) {
t.Errorf("issue %d: %s %q (counts %v), want %s %q", c.n, it.State, it.Why, counts, c.state, c.why)
}
}
// The other delivery lines a resolved issue carries on the live tracker (981, 1290 and 1235 on 2026-10-26).
for line, state := range map[string]string{
"fix not delivered: mesh-catalog#357 stopped:": StateStuck,
"fix not delivered: mesh-catalog#389 failed:": StateStuck,
"nothing heard from the delivery of mesh-delivery#5": StateWaiting,
} {
if it, _ := issueItem(trackerRow{Number: 1, Status: "resolved", Delivery: line}); it.State != state {
t.Errorf("resolved with %q: %s, want %s", line, it.State, state)
}
}
at := func(h int) *time.Time { t := time.Date(2026, 10, 26, h, 0, 0, 0, time.UTC); return &t }
for _, c := range []struct {
name string
kids []Item
state string
done int
moved *time.Time
}{
{"all done", []Item{{State: StateDone, Moved: at(9)}, {State: StateDone, Moved: at(11)}}, StateDone, 2, at(11)},
{"one moves", []Item{{State: StateDone}, {State: StateMoving, Moved: at(12)}, {State: StateWaiting}}, StateMoving, 1, at(12)},
{"one stuck outranks moving", []Item{{State: StateMoving}, {State: StateStuck}}, StateStuck, 0, nil},
{"only waiting", []Item{{State: StateDone}, {State: StateWaiting}}, StateWaiting, 1, nil},
{"no issue yet", nil, StateWaiting, 0, nil},
} {
var p Item
rollUp(&p, c.kids)
if p.State != c.state || p.Done != c.done || !reflect.DeepEqual(p.Moved, c.moved) {
t.Errorf("%s: %s %d %v", c.name, p.State, p.Done, p.Moved)
}
}
}
// 1947/AC1 (its unit side): design 47 in its two forms, and one milestone.
func TestProgressOfADesignMinimalAndDetailed(t *testing.T) {
seats := newSeatsWorld(t)
k := &KB{Records: progressRecords(), Seats: seats.ask, Now: func() time.Time { return time.Date(2026, 10, 26, 15, 30, 0, 0, time.UTC) }}
p, err := k.Progress(ProgressAsk{Of: "design 47"})
if err != nil {
t.Fatal(err)
}
raw, _ := json.Marshal(p)
if len(raw) > DefaultBound || p.Detail != DetailMinimal || !strings.Contains(p.Source, "the issue tracker's milestone records of design 47") {
t.Fatalf("%d bytes, %s, %s", len(raw), p.Detail, p.Source)
}
if p.Cut != "" || len(p.Items) != 0 {
t.Errorf("a minimal answer leaves the items to its tree and is not a cut: cut %q, %d items", p.Cut, len(p.Items))
}
warns := []string{"mesh-delivery.show a answered something else: x", "issue-tracker.get 1: refused", "the tracker did not name 2", "issue-tracker.get 3 answered something else: y"}
callsFirst(warns)
if strings.Join(warns, "|") != "issue-tracker.get 1: refused|the tracker did not name 2|mesh-delivery.show a answered something else: x|issue-tracker.get 3 answered something else: y" {
t.Errorf("call failures do not come first: %q", warns)
}
if seats.asked["seat:issue-tracker.list"] != 1 || seats.asked["seat:mesh-delivery.deliveries"] != 0 || seats.asked["seat:issue-tracker.get"] != 0 {
t.Fatalf("minimal asked %v", seats.asked)
}
if w := strings.Join(p.Warnings, "\n"); !strings.Contains(w, "the tracker neither answered nor named missing") || !strings.Contains(w, "973, 525") {
t.Errorf("a row the tracker did not answer is not said: %v", p.Warnings)
}
if big, _ := k.Progress(ProgressAsk{Of: "design 47", Bound: 8192}); big.Cut != "" || big.Tree != p.Tree {
t.Errorf("a minimal answer at bound 8192 is cut: %q", big.Cut)
}
// A design whose head the records module cannot read is said in a warning beside the tracker-built tree, never a failure.
kb := &KB{Records: brokenRead{progressRecords()}, Seats: newSeatsWorld(t).ask, Now: k.Now}
if bp, err := kb.Progress(ProgressAsk{Of: "design 47"}); err != nil || !strings.Contains(strings.Join(bp.Warnings, "\n"), "does not read") ||
!strings.Contains(bp.Tree, "design 47") || !strings.Contains(bp.Tree, "R6") {
t.Fatalf("an unreadable design: %v %+v", err, bp)
}
if mp, err := kb.Progress(ProgressAsk{Of: "mesh"}); err != nil || !strings.Contains(strings.Join(mp.Warnings, "\n"), "does not read") {
t.Fatalf("the mesh level drops an unread design silently: %v %v", err, mp.Warnings)
}
if d := parseDesign(DesignsFolder+"/47-x.md", "---\nstatus: in-progress\n"); d.Unread == "" {
t.Errorf("a frontmatter cut before its close is not said")
}
lines := strings.Split(p.Tree, "\n")
if !strings.HasPrefix(lines[0], "✗ design 47 · Delivery: from a commit to delivered — ") {
t.Fatalf("first line %q", lines[0])
}
for _, want := range []string{"✗ R6 4/7 1945 fixing since", "✗ 3-fix 0/1 1049 fixing, worker fix-chain-cat@shanks stale since"} {
if !strings.Contains(p.Tree, want) {
t.Errorf("no %q in\n%s", want, p.Tree)
}
}
d, err := k.Progress(ProgressAsk{Of: "design 47", Detail: DetailDetailed, Bound: MostBound})
if err != nil {
t.Fatal(err)
}
for _, want := range []string{"├── ▶ 1946 ", "resolved · fix merged, not delivered: mesh-catalog#475",
"▶ 1945 The controller still plans", "jschoubben/car-hunter@cc4c8ce12901 ready since 10-26 17:05, waits for its merge",
"depends on 1943", "97 notes; last 10-26 17:12 by shanks.node-tools"} {
if !strings.Contains(d.Tree, want) {
t.Errorf("detailed: no %q in\n%s", want, d.Tree)
}
}
if len(d.Items) != 1 || d.Items[0].ID != "design 47" {
t.Fatalf("items %+v", d.Items)
}
// The groups went (design 47 H §764, H-A-125): a detailed answer asks none and draws no group line.
if seats.asked["seat:mesh-delivery.groups"] != 0 {
t.Errorf("detailed asked groups %d times", seats.asked["seat:mesh-delivery.groups"])
}
m, err := k.Progress(ProgressAsk{Of: "milestone 47/r6", Detail: DetailDetailed})
if err != nil {
t.Fatal(err)
}
if !strings.HasPrefix(m.Tree, "✗ milestone 47/R6 · ") || !strings.Contains(m.Tree, "✓ 1130") {
t.Fatalf("milestone:\n%s", m.Tree)
}
small, _ := k.Progress(ProgressAsk{Of: "design 47", Detail: DetailDetailed, Bound: LeastBound})
if raw, _ := json.Marshal(small); len(raw) > LeastBound || !strings.Contains(small.Cut, "raise bound") {
t.Fatalf("%d bytes within %d; cut %q", len(raw), LeastBound, small.Cut)
}
for _, bad := range []ProgressAsk{{Of: "design"}, {Of: "milestone 47/R99"}, {Of: "design 47", Detail: "full"}, {Of: "design 57"}} {
if _, err := k.Progress(bad); err == nil {
t.Errorf("%+v was answered", bad)
}
}
}
// 1947/AC5: an issue's own level, and a record's: the designs that name it and the issues linked to it.
func TestProgressOfAnIssueAndARecord(t *testing.T) {
w := imported(t, newMemStore())
seats := newSeatsWorld(t)
seats.linked["decision:0276"] = []int{1942, 1945}
w.k.Records, w.k.Seats = progressRecords(), seats.ask
p, err := w.k.Progress(ProgressAsk{Of: "issue 1945"})
if err != nil {
t.Fatal(err)
}
for _, want := range []string{"▶ issue 1945 · The controller still plans", "97 notes", "depends on 1943",
"jschoubben/car-hunter@cc4c8ce12901 ready"} {
if !strings.Contains(p.Tree, want) {
t.Errorf("issue: no %q in\n%s", want, p.Tree)
}
}
r, err := w.k.Progress(ProgressAsk{Of: "ADR 0276", Detail: DetailDetailed})
if err != nil {
t.Fatal(err)
}
for _, want := range []string{"ADR 0276 · ", "named by design 47 (in-progress)", "▶ 1 of 2 linked issues done", "✓ 1942"} {
if !strings.Contains(r.Tree, want) {
t.Errorf("record: no %q in\n%s", want, r.Tree)
}
}
if _, err := w.k.Progress(ProgressAsk{Of: "issue 99999"}); err == nil {
t.Error("an issue the tracker does not hold was answered")
}
}
// sinceWorld plays the tracker and the delivery seat from what they answered on 2026-10-28 (testdata/progress/since):
// a get or a show it holds no answer for is refused, as a seat that cannot answer. The tracker's changes answers what
// mesh-issues' verb made of 1422's open and move to fixing (testdata/progress/README.md); without changes it is
// refused, as by a tracker that has no such verb yet.
func sinceWorld(t *testing.T, changes bool) func(string, any) (json.RawMessage, error) {
t.Helper()
read := func(name string) json.RawMessage { return readFixture(t, filepath.Join("since", name)) }
var rows []json.RawMessage
if err := json.Unmarshal(read("rows.json"), &rows); err != nil {
t.Fatal(err)
}
byNumber := map[int]json.RawMessage{}
for _, r := range rows {
var n struct{ Number int }
_ = json.Unmarshal(r, &n)
byNumber[n.Number] = r
}
shows := map[string]string{"novox/mesh-catalog@470687ea4cce": "show-mesh-catalog-539.json", "novox/mesh-catalog@f5d4b2f86ed4": "show-mesh-catalog-537.json",
"novox/mesh-delivery@2b801f5bd49a": "show-mesh-delivery-94.json", "novox/de-spiegel@fba6dbe3259e": "show-de-spiegel-6.json"}
return func(key string, body any) (json.RawMessage, error) {
raw, _ := json.Marshal(body)
var a struct {
Numbers []int `json:"numbers"`
Number int `json:"number"`
ID string `json:"id"`
One string `json:"one"`
}
_ = json.Unmarshal(raw, &a)
switch key {
case MilestonesVerb:
return read("milestone-47-6.json"), nil
case "seat:issue-tracker.list":
var out []json.RawMessage
for _, n := range a.Numbers {
if r, ok := byNumber[n]; ok {
out = append(out, r)
}
}
return json.Marshal(map[string]any{"rows": out, "matched": len(out)})
case "seat:issue-tracker.changes":
if changes {
return read("changes.json"), nil
}
return nil, errors.New("mesh-issues has no tool issue-tracker.changes")
case "seat:issue-tracker.get":
if a.Number == 1422 || a.Number == 1956 {
return read(fmt.Sprintf("get-%d.json", a.Number)), nil
}
case "seat:mesh-delivery.deliveries":
return read("deliveries.json"), nil
case "seat:mesh-delivery.show":
if f, ok := shows[a.ID]; ok {
return read(f), nil
}
}
return nil, os.ErrNotExist
}
}
// The operator, 2026-10-28: "can the progress tool also report the progress made since the last call, or maybe better,
// the last 60 minutes". With since, an answer lists only what changed in that window under of, read from the
// tracker's notes, links, workers and closes, its milestones' history and mesh-delivery's transitions and checks.
func TestProgressSinceAWindowSaysOnlyWhatChanged(t *testing.T) {
at := func(s string) *time.Time { v, _ := time.Parse(time.RFC3339, s); return &v }
k := &KB{Records: progressRecords(), Seats: sinceWorld(t, true), Now: func() time.Time { return *at("2026-10-28T11:13:30Z") }}
p, err := k.Progress(ProgressAsk{Of: "issue 1422", Since: "2h"})
if err != nil {
t.Fatal(err)
}
lines := strings.Split(p.Tree, "\n")
if lines[0] != "17 changes in the last 120 min under issue 1422 (since "+when(at("2026-10-28T09:13:30Z"))+")" || p.Changes != 17 || p.Since != "2h0m0s" {
t.Fatalf("%d changes, since %q:\n%s", p.Changes, p.Since, p.Tree)
}
for _, want := range []string{
"▶ 1422 " + clip("The catch-up reads the trunk 'main' of repositories the catalogue follows by another branch or by a commit, and the forge holds none", 80) + " — open → fixing by fix-trunk-unknown@shanks " + when(at("2026-10-28T09:38:37Z")) +
"; 9 notes, the last " + when(at("2026-10-28T11:05:21Z")) + " by shanks.node-tools",
"✓ mesh-catalog#537 (1422) opened " + when(at("2026-10-28T10:20:56Z")) + " · check pass " + when(at("2026-10-28T10:30:45Z")) + " · merged " + when(at("2026-10-28T10:34:49Z")) + ", on the machines",
"✓ mesh-delivery#94 (1126, 1422) opened ",
"▶ mesh-catalog#539 (1422, 1956) opened " + when(at("2026-10-28T11:07:42Z")) + ", now ready, waits for its merge",
} {
if !strings.Contains(p.Tree, want) {
t.Errorf("no %q in\n%s", want, p.Tree)
}
}
if strings.Contains(p.Tree, "de-spiegel") || strings.Contains(p.Tree, "triage") {
t.Errorf("a change outside issue 1422 or the window is said:\n%s", p.Tree)
}
w := strings.Join(p.Warnings, "\n")
if !strings.Contains(w, "keeps no time a merge reached its machines") || strings.Contains(w, "issue-tracker.changes") {
t.Errorf("the warnings: %v", p.Warnings)
}
// A tracker that cannot say its moves: each is said by the status it reached, and that is said.
old := &KB{Records: progressRecords(), Seats: sinceWorld(t, false), Now: k.Now}
o, err := old.Progress(ProgressAsk{Of: "issue 1422", Since: "2h"})
if err != nil {
t.Fatal(err)
}
if !strings.Contains(o.Tree, " — → fixing by fix-trunk-unknown@shanks "+when(at("2026-10-28T09:38:37Z"))) || o.Changes != 17 ||
!strings.Contains(strings.Join(o.Warnings, "\n"), "issue-tracker.changes: mesh-issues has no tool issue-tracker.changes; a move is said by the status it reached") {
t.Errorf("without changes:\n%s\n%v", o.Tree, o.Warnings)
}
d, err := k.Progress(ProgressAsk{Of: "issue 1422", Since: "2h", Detail: DetailDetailed})
if err != nil {
t.Fatal(err)
}
for _, want := range []string{"│ ├── open → fixing " + when(at("2026-10-28T09:38:37Z")) + " by shanks.node-tools, worker fix-trunk-unknown@shanks",
"│ ├── noted " + when(at("2026-10-28T09:38:09Z")) + " by shanks.node-tools: lead-47@shanks 2026-10-28 09:40Z.",
" └── merged " + when(at("2026-10-28T10:34:49Z")) + ": on the trunk its modules follow: merged there"} {
if !strings.Contains(d.Tree, want) {
t.Errorf("detailed: no %q in\n%s", want, d.Tree)
}
}
// A milestone's issue the tracker's get cannot answer falls back to its row's moved time, said as such.
m, err := k.Progress(ProgressAsk{Of: "milestone 47/L2", Since: "60m"})
if err != nil {
t.Fatal(err)
}
for _, want := range []string{"6 changes in the last 60 min under milestone 47/L2", "▶ 1126 " + clip("About 49,800 controller code lines stay after the delivery model, against a first limit of 25,000", 80) + " — moved " +
when(at("2026-10-28T11:13:28Z")) + ", now fixing (lead-47@shanks)", "✓ de-spiegel#6 (1126) check pass ", "✓ mesh-delivery#94 (1126, 1422) opened "} {
if !strings.Contains(m.Tree, want) {
t.Errorf("milestone: no %q in\n%s", want, m.Tree)
}
}
if w := strings.Join(m.Warnings, "\n"); !strings.Contains(w, "issue-tracker.get 1126") {
t.Errorf("the fallback is not said: %v", m.Warnings)
}
if small, _ := k.Progress(ProgressAsk{Of: "issue 1422", Since: "2h", Detail: DetailDetailed, Bound: LeastBound}); small == nil || size(small) > LeastBound || !strings.Contains(small.Cut, "raise bound") {
t.Errorf("a window's answer is not kept within its bound: %+v", small)
}
// A milestone's move, from its history: what it was before, what it is now, who moved it and when.
k.Now = func() time.Time { return *at("2026-10-26T18:40:00Z") }
ds, err := k.Progress(ProgressAsk{Of: "design 47", Since: "60m"})
if err != nil {
t.Fatal(err)
}
if ds.Tree != "1 change in the last 60 min under design 47 (since "+when(at("2026-10-26T17:40:00Z"))+")\n└── ✓ milestone 47/6 open → closed: folded into R4g · by shanks.node-tools "+when(at("2026-10-26T18:10:10Z")) {
t.Errorf("design:\n%s", ds.Tree)
}
for _, bad := range []string{"0m", "-5m", "25h", "a day", "5"} {
if _, err := k.Progress(ProgressAsk{Of: "issue 1422", Since: bad}); err == nil || !strings.Contains(err.Error(), "since") {
t.Errorf("since %q: %v", bad, err)
}
}
}