72 lines
3.4 KiB
Go
72 lines
3.4 KiB
Go
package buildrun
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/delivery"
|
|
)
|
|
|
|
func goAsk(id string) delivery.StepAsk {
|
|
return delivery.StepAsk{ID: id, Kind: delivery.AskDelivery, Language: delivery.AskGo, Asker: "mesh-delivery-builder", At: time.Now(),
|
|
Build: &delivery.BuildJob{Module: "m", Path: ".", Fetch: map[string]any{"repository": "novox/x", "commit": strings.Repeat("a", 40)},
|
|
Artifacts: []delivery.AskArtifact{{Artifact: "program"}}}}
|
|
}
|
|
|
|
// 1887/A4a: an asker puts the ask once and answers the step a build node wrote for it, naming the node; one that did not
|
|
// pass is an error naming the node and why; a wait of an ask already put puts nothing.
|
|
func TestAnAskerPutsOnceAndReadsTheStep(t *testing.T) {
|
|
f := &FakeAsks{Answer: func(a delivery.StepAsk) delivery.Step {
|
|
return delivery.Step{ID: a.ID, Node: "ace", State: delivery.StepPassed, Result: []byte(`{"artifacts":[]}`)}
|
|
}}
|
|
k := Asker{Publisher: f, Waiter: f}
|
|
step, err := k.Ask(context.Background(), goAsk("mvl0frv18d1957"))
|
|
if err != nil || step.Node != "ace" || len(f.Asks()) != 1 {
|
|
t.Fatalf("step %+v, %v, asks %d", step, err, len(f.Asks()))
|
|
}
|
|
f.Answer = func(a delivery.StepAsk) delivery.Step {
|
|
return delivery.Step{ID: a.ID, Node: "shanks", State: delivery.StepRefused, Reason: "go 1.27 installed"}
|
|
}
|
|
if _, err := k.Ask(context.Background(), goAsk("mvl0frv18d1958")); err == nil || !strings.Contains(err.Error(), "shanks refused: go 1.27 installed") {
|
|
t.Fatalf("a refused step: %v", err)
|
|
}
|
|
// review round 2 item 1: an ask that waits in its stream for a free slot is not bounded; once a node writes its step
|
|
// running, the step is bounded from its start, and the error names the node.
|
|
g := &FakeAsks{}
|
|
k = Asker{Publisher: g, Waiter: g, Bound: 20 * time.Millisecond}
|
|
waiting, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
|
|
defer cancel()
|
|
if _, err := k.Wait(waiting, goAsk("mvl0frv18d1959")); err != context.DeadlineExceeded {
|
|
t.Fatalf("an ask no node took: %v, want it still waiting when ctx ended", err)
|
|
}
|
|
g.Write(delivery.Step{ID: "mvl0frv18d1961", Node: "ace", State: delivery.StepRunning, Started: time.Now()})
|
|
if _, err := k.Wait(context.Background(), goAsk("mvl0frv18d1961")); err == nil || !strings.Contains(err.Error(), "on ace did not end within") {
|
|
t.Fatalf("a step that never ends: %v", err)
|
|
}
|
|
if len(g.Asks()) != 0 {
|
|
t.Fatal("a wait put an ask")
|
|
}
|
|
}
|
|
|
|
// Review (issue 734 path): an ask taken again by the same node (its build module replaced mid-run) is bounded from the
|
|
// new run's start, so its pass is answered after the first run's bound would have ended the wait.
|
|
func TestARedeliveryToTheSameNodeRestartsTheBound(t *testing.T) {
|
|
f := &FakeAsks{}
|
|
k := Asker{Publisher: f, Waiter: f, Bound: 60 * time.Millisecond}
|
|
const id = "mvl0frv18d1962"
|
|
first := time.Now()
|
|
f.Write(delivery.Step{ID: id, Node: "ace", State: delivery.StepRunning, Started: first})
|
|
go func() {
|
|
time.Sleep(40 * time.Millisecond)
|
|
f.Write(delivery.Step{ID: id, Node: "ace", State: delivery.StepRunning, Started: time.Now()})
|
|
time.Sleep(50 * time.Millisecond) // past the first run's bound, inside the second's
|
|
f.Write(delivery.Step{ID: id, Node: "ace", State: delivery.StepPassed, Started: time.Now()})
|
|
}()
|
|
step, err := k.Wait(context.Background(), goAsk(id))
|
|
if err != nil || step.State != delivery.StepPassed {
|
|
t.Fatalf("step %+v, %v, want the redelivered run's pass", step, err)
|
|
}
|
|
}
|