85 lines
3.9 KiB
Go
85 lines
3.9 KiB
Go
package build
|
|
|
|
import (
|
|
"context"
|
|
"git.novox.be/novox/mesh-sdk/go/delivery/buildrun"
|
|
"testing"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/catalogue"
|
|
"git.novox.be/novox/mesh-sdk/go/delivery"
|
|
)
|
|
|
|
func haveValue(t *testing.T, phase delivery.Phase, health delivery.Health) []byte {
|
|
t.Helper()
|
|
b, err := delivery.EncodeHave(delivery.Have{Phase: phase, Health: health})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return b
|
|
}
|
|
|
|
// 1. A module of an archive only: the real indexer gives an archive no language (inputs.go languagesOf), so its
|
|
// fingerprint names no toolchain, and the builder builds it on the build module's nodes with no toolchain agreed.
|
|
func TestAnArchiveOnlyModuleIsBuiltAlthoughItsFingerprintNamesNoToolchain(t *testing.T) { // review round 4, 1
|
|
r := newRig(t, archiveA)
|
|
v := func() delivery.BuilderBuild {
|
|
r.b.Module(context.Background(), "m", moduleValueWith(t, "modules/m", nil))
|
|
r.b.Wait()
|
|
if _, ok := r.st.vals[r.key]; !ok {
|
|
t.Fatal("no build key was written for the archive-only module")
|
|
}
|
|
return valueOf(t, r.st, r.key)
|
|
}()
|
|
if v.State != delivery.BuildDone || len(v.Artifacts) != 1 || v.Artifacts[0].Kind != "archive" || len(v.Toolchains) != 0 {
|
|
t.Fatalf("build = %+v, want done with the archive and no toolchain named", v)
|
|
}
|
|
if n := len(r.bm.callsOf("build_go_build")); n != 1 {
|
|
t.Errorf("%d go builds, want one, on one node (ADR 0478 clause 4)", n)
|
|
}
|
|
}
|
|
|
|
func TestABundleAndAnArchiveOfOneBuildModuleStillNeedTheAgreedToolchain(t *testing.T) { // review round 4, 1
|
|
p, err := PlanOf(catalogue.Manifest{Module: "m", Build: &catalogue.Build{Artifacts: []catalogue.Artifact{goBundle, archiveA}}})
|
|
if err != nil || !p.NeedsToolchain(buildrun.GoBuildModule) {
|
|
t.Errorf("a plan with a Go bundle: %v, %v", p.NeedsToolchain(buildrun.GoBuildModule), err)
|
|
}
|
|
p, _ = PlanOf(catalogue.Manifest{Module: "m", Build: &catalogue.Build{Artifacts: []catalogue.Artifact{archiveA}}})
|
|
if p.NeedsToolchain(buildrun.GoBuildModule) {
|
|
t.Error("a plan of an archive needs a toolchain")
|
|
}
|
|
}
|
|
|
|
func TestClaimLeavesAKeyFailedForDifferingDigestsAlone(t *testing.T) { // review round 4, 2
|
|
st := newMem()
|
|
seed(t, st, delivery.BuilderBuild{State: delivery.BuildFailed, Error: buildrun.DigestsDifferPrefix + " the nodes built tool to different digests: ace x; novox y"})
|
|
writes := st.writes
|
|
got, err := (Claimer{Store: st, By: "novox.a"}).Claim(context.Background(), "m", fp1, "", ClaimOptions{TakeOver: true})
|
|
if err != nil || got != nil || st.writes != writes {
|
|
t.Errorf("claim = %v, %v, %d writes (was %d), want none and no write", got, err, st.writes, writes)
|
|
}
|
|
}
|
|
|
|
// 6. A key found building is taken over, whoever holds it.
|
|
func TestABuildLeftBuildingByAnyBuilderIsTakenOverAtStart(t *testing.T) { // review round 4, 6; 1607/AC3, ADR 0478 clauses 5, 6
|
|
st := newMem()
|
|
seed(t, st, delivery.BuilderBuild{State: delivery.BuildBuilding, By: "novox.a"})
|
|
if got, err := (Claimer{Store: st, By: "novox.a"}).Claim(context.Background(), "m", fp1, "", ClaimOptions{}); err != nil || got == nil {
|
|
t.Errorf("own building key: claim = %v, %v, want it taken again", got, err)
|
|
}
|
|
if got, err := (Claimer{Store: st, By: "ace.b"}).Claim(context.Background(), "m", fp1, "", ClaimOptions{TakeOver: true}); err != nil || got == nil || got.Build.By != "novox.a" {
|
|
t.Errorf("another node's building key at start: claim = %v, %v, want it taken over", got, err)
|
|
}
|
|
if got, _ := (Claimer{Store: st, By: "ace.b"}).Claim(context.Background(), "m", fp1, "", ClaimOptions{}); got != nil {
|
|
t.Errorf("another builder's building key after the start was taken: a running builder's key is its own")
|
|
}
|
|
}
|
|
|
|
func TestABuilderFindingAKeyBuildingByAnotherNodeBuildsItOnStart(t *testing.T) { // review round 4, 6
|
|
r := newRig(t, goBundle)
|
|
seed(t, r.st, delivery.BuilderBuild{State: delivery.BuildBuilding, By: "ace.builder", Manifest: manifestD})
|
|
v := r.consider(t, "modules/m")
|
|
if v.State != delivery.BuildDone || v.By != "novox.builder" {
|
|
t.Errorf("build = %+v, want it taken over and done by novox.builder", v)
|
|
}
|
|
}
|