294 lines
13 KiB
Go
294 lines
13 KiB
Go
//go:build integration
|
|
|
|
package main
|
|
|
|
import (
|
|
"errors"
|
|
"reflect"
|
|
"slices"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/novox/mesh-controller/internal/inventory"
|
|
)
|
|
|
|
func TestAStopWithoutAMergeWalksTheOthersAgain(t *testing.T) {
|
|
open := windowed(t)
|
|
groupsWaiting(t, "pr/cat1aaaaaaaa")
|
|
endsItsLine(t)
|
|
asksRecorded(t)
|
|
ctx := t.Context()
|
|
cat := catalogueMerge("cat1aaaaaaaa", "app", t0)
|
|
one := fromHead(repoMerge("one", "one1bbbbbbbb", t0.Add(5*time.Second)), cat.Head)
|
|
hear(t, open, cat, t0.Add(time.Second))
|
|
hear(t, open, one, t0.Add(6*time.Second))
|
|
cutAt(t, open, t0.Add(2*time.Minute))
|
|
ws, _ := walks(t, open)
|
|
if len(ws) != 1 || !ws[0].Open() {
|
|
t.Fatalf("no open walk to stop: %+v", ws)
|
|
}
|
|
stopped := ws[0]
|
|
p, said, err := stopWalkWithout(ctx, open.inventory, stopped.ID, "mesh-delivery for jochen", "its group stopped",
|
|
[]string{"novox/mesh-catalog@" + cat.Commit}, t0.Add(3*time.Minute))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if p.State != inventory.PlanFailed || p.Delivery.Stopped == "" || p.Delivery.WalkedAgainBy == "" ||
|
|
!reflect.DeepEqual(p.Delivery.LeftOut, []inventory.PlanLeftOut{{Repository: "novox/mesh-catalog", Commit: cat.Commit}}) {
|
|
t.Fatalf("the stopped walk reads %s %+v", p.State, p.Delivery)
|
|
}
|
|
if said.WalkedAgainBy != p.Delivery.WalkedAgainBy || !reflect.DeepEqual(said.WalkedAgain, []string{"novox/one@" + one.Commit}) {
|
|
t.Fatalf("the stop answered %+v", said)
|
|
}
|
|
again, err := open.inventory.MergesOf(ctx, p.Delivery.WalkedAgainBy)
|
|
if err != nil || len(again) != 1 || again[0].Commit != one.Commit {
|
|
t.Fatalf("the fresh batch answers %+v (%v); want the other repository's merge alone", again, err)
|
|
}
|
|
if left, _ := open.inventory.MergesOf(ctx, stopped.ID); len(left) != 1 || left[0].Commit != cat.Commit {
|
|
t.Fatalf("the stopped walk still answers %+v; want the left-out merge alone", left)
|
|
}
|
|
cutAt(t, open, t0.Add(4*time.Minute))
|
|
fresh, err := open.inventory.PlanByID(ctx, p.Delivery.WalkedAgainBy)
|
|
if err != nil || fresh.Batch() || !fresh.Open() {
|
|
t.Fatalf("the fresh batch was not cut into a walk: %s %v", fresh.State, err)
|
|
}
|
|
if _, in := fresh.Modules["one"]; !in {
|
|
t.Fatalf("the fresh walk does not build one: %v", fresh.Modules)
|
|
}
|
|
if _, in := fresh.Modules["app"]; in {
|
|
t.Fatalf("the fresh walk builds app, whose merge was left out: %v", fresh.Modules)
|
|
}
|
|
if len(fresh.Delivery.Merges) != 1 || fresh.Delivery.Merges[0].Commit != one.Commit {
|
|
t.Fatalf("the fresh walk answers %+v", fresh.Delivery.Merges)
|
|
}
|
|
// A stopped walk starts no search of its own (ADR 0276 decision 3 is for a failed one).
|
|
cutAt(t, open, t0.Add(5*time.Minute))
|
|
if alone, _ := open.inventory.AloneMerges(ctx); len(alone) != 0 {
|
|
t.Fatalf("a merge of the stopped walk waits to be walked alone: %+v", alone)
|
|
}
|
|
}
|
|
|
|
func TestAStopWithoutAMergeEndsTheMergesThatContainIt(t *testing.T) {
|
|
open := windowed(t)
|
|
groupsWaiting(t, "pr/cat1aaaaaaaa")
|
|
endsItsLine(t)
|
|
asksRecorded(t)
|
|
ctx := t.Context()
|
|
first := catalogueMerge("cat1aaaaaaaa", "app", t0)
|
|
later := catalogueMerge("cat2cccccccc", "notes", t0.Add(10*time.Second))
|
|
one := fromHead(repoMerge("one", "one1bbbbbbbb", t0.Add(5*time.Second)), first.Head)
|
|
hear(t, open, first, t0.Add(time.Second))
|
|
hear(t, open, one, t0.Add(6*time.Second))
|
|
hear(t, open, later, t0.Add(11*time.Second))
|
|
cutAt(t, open, t0.Add(2*time.Minute))
|
|
ws, _ := walks(t, open)
|
|
walk := ws[0]
|
|
|
|
if _, _, err := stopWalkWithout(ctx, open.inventory, walk.ID, "mesh-delivery for jochen", "x",
|
|
[]string{"novox/mesh-catalog@ffffffffffff"}, t0.Add(3*time.Minute)); err == nil {
|
|
t.Fatal("a stop leaving out a merge the walk does not answer was taken")
|
|
}
|
|
if p, _ := open.inventory.PlanByID(ctx, walk.ID); !p.Open() {
|
|
t.Fatalf("a refused stop ended the walk: %s", p.State)
|
|
}
|
|
|
|
p, said, err := stopWalkWithout(ctx, open.inventory, walk.ID, "mesh-delivery for jochen", "its group stopped",
|
|
[]string{"novox/mesh-catalog@" + first.Commit}, t0.Add(3*time.Minute))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := []inventory.PlanLeftOut{{Repository: "novox/mesh-catalog", Commit: first.Commit},
|
|
{Repository: "novox/mesh-catalog", Commit: later.Commit, Contains: first.Commit}}
|
|
if !reflect.DeepEqual(p.Delivery.LeftOut, want) || !reflect.DeepEqual(said.LeftOut, want) {
|
|
t.Fatalf("left out %+v, said %+v; want %+v", p.Delivery.LeftOut, said.LeftOut, want)
|
|
}
|
|
if !strings.Contains(p.Note, later.Commit[:8]) || !strings.Contains(p.Note, p.Delivery.WalkedAgainBy) {
|
|
t.Fatalf("the stopped walk's note does not name the merge ended with it and the fresh batch: %q", p.Note)
|
|
}
|
|
again, _ := open.inventory.MergesOf(ctx, p.Delivery.WalkedAgainBy)
|
|
if len(again) != 1 || again[0].Commit != one.Commit {
|
|
t.Fatalf("walked again: %+v; want the other repository's merge alone", again)
|
|
}
|
|
|
|
// Nothing left once the other repository's merge is left out too: the fresh walk is stopped, and nothing more.
|
|
cutAt(t, open, t0.Add(4*time.Minute))
|
|
fresh, _ := open.inventory.PlanByID(ctx, p.Delivery.WalkedAgainBy)
|
|
q, said, err := stopWalkWithout(ctx, open.inventory, fresh.ID, "mesh-delivery for jochen", "that one too",
|
|
[]string{"novox/one@" + one.Commit}, t0.Add(5*time.Minute))
|
|
if err != nil || q.State != inventory.PlanFailed || q.Delivery.WalkedAgainBy != "" || said.WalkedAgainBy != "" {
|
|
t.Fatalf("a stop leaving nothing to walk: %s %+v %+v %v", q.State, q.Delivery, said, err)
|
|
}
|
|
if _, bs := walks(t, open); len(bs) != 0 {
|
|
t.Fatalf("a batch of nothing was made: %+v", bs)
|
|
}
|
|
}
|
|
|
|
func TestAStopWalksTheOthersAgainInTheOpenBatch(t *testing.T) {
|
|
open := windowed(t)
|
|
groupsWaiting(t, "pr/cat1aaaaaaaa")
|
|
endsItsLine(t)
|
|
asksRecorded(t)
|
|
ctx := t.Context()
|
|
cat := catalogueMerge("cat1aaaaaaaa", "app", t0)
|
|
one1 := fromHead(repoMerge("one", "one1bbbbbbbb", t0.Add(5*time.Second)), cat.Head)
|
|
hear(t, open, cat, t0.Add(time.Second))
|
|
hear(t, open, one1, t0.Add(6*time.Second))
|
|
cutAt(t, open, t0.Add(2*time.Minute))
|
|
ws, _ := walks(t, open)
|
|
walk := ws[0]
|
|
one2 := repoMerge("one", "one2cccccccc", t0.Add(3*time.Minute))
|
|
hear(t, open, one2, t0.Add(3*time.Minute))
|
|
_, bs := walks(t, open)
|
|
if len(bs) != 1 {
|
|
t.Fatalf("the merge heard while the walk ran is in %d batches", len(bs))
|
|
}
|
|
waiting := bs[0]
|
|
p, said, err := stopWalkWithout(ctx, open.inventory, walk.ID, "mesh-delivery for jochen", "its group stopped",
|
|
[]string{"novox/mesh-catalog@" + cat.Commit}, t0.Add(3*time.Minute+10*time.Second))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if p.Delivery.WalkedAgainBy != waiting.ID || said.WalkedAgainBy != waiting.ID {
|
|
t.Fatalf("walked again by %q (said %q); want the open batch %s", p.Delivery.WalkedAgainBy, said.WalkedAgainBy, waiting.ID)
|
|
}
|
|
if _, bs := walks(t, open); len(bs) != 1 {
|
|
t.Fatalf("%d batches; want the open one alone", len(bs))
|
|
}
|
|
b, _ := open.inventory.PlanByID(ctx, waiting.ID)
|
|
if b.Delivery.Batch == nil || !b.Delivery.Batch.Closed || !slices.Contains(b.Delivery.Batch.Withheld, "app") {
|
|
t.Fatalf("the open batch reads %+v; want its window closed and app withheld", b.Delivery.Batch)
|
|
}
|
|
// Its window closed by the stop, not by the clock: cut at once.
|
|
cutAt(t, open, t0.Add(3*time.Minute+11*time.Second))
|
|
fresh, _ := open.inventory.PlanByID(ctx, waiting.ID)
|
|
if fresh.Batch() || fresh.CommitOf("novox/one") != one2.Commit {
|
|
t.Fatalf("the batch is %s at %q; want it cut, walking the newer commit", fresh.State, fresh.CommitOf("novox/one"))
|
|
}
|
|
var answered []string
|
|
for _, m := range fresh.Delivery.Merges {
|
|
answered = append(answered, m.Commit+">"+m.Carried)
|
|
}
|
|
if !slices.Contains(answered, one1.Commit+">"+one2.Commit) || !slices.Contains(answered, one2.Commit+">") {
|
|
t.Fatalf("the walk answers %v; want the earlier merge carried by the later", answered)
|
|
}
|
|
}
|
|
|
|
func TestAStopNamesWhatStaysOnTheMachinesAndWhatStillCarriesIt(t *testing.T) {
|
|
open := windowed(t)
|
|
groupsWaiting(t, "pr/cat1aaaaaaaa")
|
|
endsItsLine(t)
|
|
asksRecorded(t)
|
|
ctx := t.Context()
|
|
cat := catalogueMerge("cat1aaaaaaaa", "app", t0)
|
|
one1 := fromHead(repoMerge("one", "one1bbbbbbbb", t0.Add(5*time.Second)), cat.Head)
|
|
hear(t, open, cat, t0.Add(time.Second))
|
|
hear(t, open, one1, t0.Add(6*time.Second))
|
|
cutAt(t, open, t0.Add(2*time.Minute))
|
|
ws, _ := walks(t, open)
|
|
walk := ws[0]
|
|
sent := t0.Add(150 * time.Second)
|
|
for name, m := range walk.Modules {
|
|
if name == "app" || name == "one" {
|
|
m.First, m.FirstAt = []string{"anchor"}, &sent
|
|
}
|
|
}
|
|
if err := open.inventory.SavePlan(ctx, &walk); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cat2 := catalogueMerge("cat2dddddddd", "notes", t0.Add(3*time.Minute))
|
|
hear(t, open, cat2, t0.Add(3*time.Minute))
|
|
_, said, err := stopWalkWithout(ctx, open.inventory, walk.ID, "mesh-delivery for jochen", "its group stopped",
|
|
[]string{"novox/mesh-catalog@" + cat.Commit}, t0.Add(3*time.Minute+10*time.Second))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !reflect.DeepEqual(said.Kept, []inventory.PlanKept{{Module: "app", Machines: []string{"anchor"}}}) {
|
|
t.Fatalf("kept %+v; want app on anchor alone (one is walked again)", said.Kept)
|
|
}
|
|
p, _ := open.inventory.PlanByID(ctx, walk.ID)
|
|
if !reflect.DeepEqual(p.Delivery.Kept, said.Kept) || !strings.Contains(p.Note, "app on anchor") {
|
|
t.Fatalf("the stopped walk's record does not name what stays: %+v %q", p.Delivery.Kept, p.Note)
|
|
}
|
|
if len(said.StillCarriedBy) != 1 || !strings.Contains(said.StillCarriedBy[0], cat2.Commit) {
|
|
t.Fatalf("still carried by %v; want the later catalogue merge waiting in the batch", said.StillCarriedBy)
|
|
}
|
|
if _, err := retryPlan(ctx, open, walk.ID); err == nil || !strings.Contains(err.Error(), "was stopped without") {
|
|
t.Fatalf("a walk stopped without some merges was retried, or refused for another reason: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestAStopWithoutAMergeLeavesItOutOfABatch(t *testing.T) {
|
|
open := windowed(t)
|
|
everyHeadWaits(t)
|
|
endsItsLine(t)
|
|
asksRecorded(t)
|
|
ctx := t.Context()
|
|
cat := catalogueMerge("cat1aaaaaaaa", "app", t0)
|
|
one := fromHead(repoMerge("one", "one1bbbbbbbb", t0.Add(5*time.Second)), cat.Head)
|
|
hear(t, open, cat, t0.Add(time.Second))
|
|
hear(t, open, one, t0.Add(6*time.Second))
|
|
_, bs := walks(t, open)
|
|
b := bs[0]
|
|
r, said, err := stopWalkWithout(ctx, open.inventory, b.ID, "mesh-delivery for jochen", "its group stopped",
|
|
[]string{"novox/mesh-catalog@" + cat.Commit}, t0.Add(10*time.Second))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if said.WalkedAgainBy != b.ID || said.Stopped == b.ID {
|
|
t.Fatalf("said %+v; want a stopped record of its own, and the batch walking the others", said)
|
|
}
|
|
if left, _ := open.inventory.MergesOf(ctx, said.Stopped); len(left) != 1 || left[0].Commit != cat.Commit {
|
|
t.Fatalf("the stopped record holds %+v", left)
|
|
}
|
|
if stopped, _ := open.inventory.PlanByID(ctx, said.Stopped); stopped.State != inventory.PlanFailed ||
|
|
stopped.Delivery.Stopped == "" || stopped.Delivery.WalkedAgainBy != b.ID {
|
|
t.Fatalf("the stopped record reads %s %+v", stopped.State, stopped.Delivery)
|
|
}
|
|
_ = r
|
|
cutAt(t, open, t0.Add(3*time.Minute))
|
|
w, _ := open.inventory.PlanByID(ctx, b.ID)
|
|
if _, in := w.Modules["app"]; in || w.Batch() {
|
|
t.Fatalf("the batch's walk is %s and builds %v; want it cut without app", w.State, w.Modules)
|
|
}
|
|
// A batch whose every merge is left out is stopped itself.
|
|
hear(t, open, catalogueMerge("cat3eeeeeeee", "notes", t0.Add(4*time.Minute)), t0.Add(4*time.Minute))
|
|
_, bs = walks(t, open)
|
|
last := bs[0]
|
|
if _, said, err := stopWalkWithout(ctx, open.inventory, last.ID, "mesh-delivery for jochen", "x",
|
|
[]string{"novox/mesh-catalog@cat3eeeeeeee"}, t0.Add(4*time.Minute+time.Second)); err != nil || said.Stopped != last.ID {
|
|
t.Fatalf("a batch left with nothing: %+v %v", said, err)
|
|
}
|
|
if p, _ := open.inventory.PlanByID(ctx, last.ID); p.State != inventory.PlanFailed || p.Batch() {
|
|
t.Fatalf("the emptied batch is %s", p.State)
|
|
}
|
|
}
|
|
|
|
func TestSavingPlansAndMovingMergesIsOneAct(t *testing.T) {
|
|
open := windowed(t)
|
|
everyHeadWaits(t)
|
|
endsItsLine(t)
|
|
ctx := t.Context()
|
|
hear(t, open, catalogueMerge("cat1aaaaaaaa", "app", t0), t0.Add(time.Second))
|
|
_, bs := walks(t, open)
|
|
stale := bs[0]
|
|
moved := stale
|
|
moved.Note = "written by somebody else"
|
|
if err := open.inventory.SavePlan(ctx, &moved); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fresh := inventory.Plan{ID: "plan-fresh", Repository: "novox/mesh-catalog", Branch: "main", Commit: "x", Created: t0,
|
|
State: inventory.PlanAssembling, Tiers: [][]string{}, Modules: map[string]*inventory.PlanModule{}}
|
|
err := open.inventory.SavePlansMoving(ctx, []*inventory.Plan{&fresh, &stale},
|
|
[]inventory.MergeMove{{Repository: "novox/mesh-catalog", Commit: "cat1aaaaaaaa", Plan: "plan-fresh"}})
|
|
if !errors.Is(err, inventory.ErrPlanMoved) {
|
|
t.Fatalf("a stale plan in the act: %v", err)
|
|
}
|
|
if _, err := open.inventory.PlanByID(ctx, "plan-fresh"); err == nil {
|
|
t.Fatal("the new plan was written though the act was refused")
|
|
}
|
|
if m, _, _ := open.inventory.MergeOf(ctx, "novox/mesh-catalog", "cat1aaaaaaaa"); m.Plan != stale.ID {
|
|
t.Fatalf("the merge moved to %q though the act was refused", m.Plan)
|
|
}
|
|
}
|