97 lines
4.2 KiB
Go
97 lines
4.2 KiB
Go
package build
|
|
|
|
import (
|
|
"errors"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/delivery"
|
|
"git.novox.be/novox/mesh-sdk/go/delivery/buildrun"
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/catalogue"
|
|
)
|
|
|
|
// manifestOf is a manifest holding these artifacts: the plan reads only their name, kind and language.
|
|
func manifestOf(artifacts ...catalogue.Artifact) catalogue.Manifest {
|
|
return catalogue.Manifest{Module: "m", Build: &catalogue.Build{Artifacts: artifacts}}
|
|
}
|
|
|
|
func TestPlanRoutesEachKindToItsBuildModule(t *testing.T) { // 1607/AC2
|
|
m := manifestOf(
|
|
catalogue.Artifact{Name: "tool", Kind: "bundle", Language: "go"},
|
|
catalogue.Artifact{Name: "web", Kind: "bundle", Language: "typescript"},
|
|
catalogue.Artifact{Name: "files", Kind: "archive"})
|
|
p, err := PlanOf(m)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := []Task{
|
|
{Artifact: "files", Kind: "archive", Module: buildrun.GoBuildModule, Language: "go"},
|
|
{Artifact: "tool", Kind: "bundle", Module: buildrun.GoBuildModule, Language: "go"},
|
|
{Artifact: "web", Kind: "bundle", Module: buildrun.NodeBuildModule, Language: "typescript"},
|
|
}
|
|
if len(p.Tasks) != len(want) {
|
|
t.Fatalf("tasks = %+v, want %+v", p.Tasks, want)
|
|
}
|
|
for i := range want {
|
|
if p.Tasks[i] != want[i] {
|
|
t.Errorf("task %d = %+v, want %+v", i, p.Tasks[i], want[i])
|
|
}
|
|
}
|
|
if modules := p.Modules(); len(modules) != 2 || modules[0] != buildrun.GoBuildModule || modules[1] != buildrun.NodeBuildModule {
|
|
t.Errorf("modules = %v", modules)
|
|
}
|
|
}
|
|
|
|
const pinned = "nats:2.11.17-alpine@sha256:3333333333333333333333333333333333333333333333333333333333333333"
|
|
|
|
func TestPlanSendsAPinnedUpstreamToTheImageBuildModulesCopyAndRefusesAnUnpinnedOne(t *testing.T) { // B3, ADR 0498 clause 4
|
|
p, err := PlanOf(manifestOf(catalogue.Artifact{Name: "ok", Kind: "archive"}, catalogue.Artifact{Name: "up", Kind: "upstream", From: pinned}))
|
|
if err != nil || len(p.Tasks) != 2 {
|
|
t.Fatalf("plan %+v, error %v", p, err)
|
|
}
|
|
if up := p.Tasks[1]; up.Artifact != "up" || up.Kind != "upstream" || up.Module != ImageBuildModule || up.From != pinned || up.Language != "" {
|
|
t.Errorf("task = %+v, want the upstream sent to %s with its pinned reference and no toolchain", up, ImageBuildModule)
|
|
}
|
|
if p.NeedsToolchain(ImageBuildModule) {
|
|
t.Error("a copy needs no toolchain")
|
|
}
|
|
_, err = PlanOf(manifestOf(catalogue.Artifact{Name: "up", Kind: "upstream", From: "nats:2.11.17-alpine"}))
|
|
if err == nil || !strings.HasPrefix(err.Error(), delivery.NotPinned+"up") || !delivery.FailedUntilChanged(err.Error()) {
|
|
t.Errorf("an upstream with no digest: error = %v, want it to open %q naming the artifact", err, delivery.NotPinned)
|
|
}
|
|
}
|
|
|
|
func TestPlanRefusesAPackageOfAnotherLanguageByName(t *testing.T) { // ADR 0498 clause 5
|
|
_, err := PlanOf(manifestOf(catalogue.Artifact{Name: "ok", Kind: "archive"}, catalogue.Artifact{Name: "pkg", Kind: "package", Language: "python"}))
|
|
var r *Refused
|
|
if err == nil || !asRefused(err, &r) || !strings.HasPrefix(err.Error(), delivery.RefusedKind) || !strings.Contains(err.Error(), "python") || !strings.Contains(err.Error(), "pkg") {
|
|
t.Errorf("error = %v, want it to open %q naming the artifact and its language", err, delivery.RefusedKind)
|
|
}
|
|
}
|
|
|
|
func TestPlanRefusesABundleOfAnotherLanguageAndAModuleWithNoArtifact(t *testing.T) {
|
|
if _, err := PlanOf(manifestOf(catalogue.Artifact{Name: "x", Kind: "bundle", Language: "python"})); err == nil || !strings.HasPrefix(err.Error(), delivery.RefusedKind) {
|
|
t.Errorf("a python bundle: error = %v, want a refusal", err)
|
|
}
|
|
p, err := PlanOf(manifestOf())
|
|
if err != nil || len(p.Tasks) != 0 {
|
|
t.Errorf("no artifact: plan %+v error %v, want an empty plan", p, err)
|
|
}
|
|
}
|
|
|
|
func asRefused(err error, target **Refused) bool { return errors.As(err, target) }
|
|
|
|
func TestPlanSendsAnImageToMeshBuildImageWithNoToolchain(t *testing.T) { // 1705a, ADR 0487 clause 5
|
|
p, err := PlanOf(manifestOf(catalogue.Artifact{Name: "img", Kind: "image"}, catalogue.Artifact{Name: "files", Kind: "archive"}))
|
|
if err != nil || len(p.Tasks) != 2 {
|
|
t.Fatalf("plan %+v, error %v", p, err)
|
|
}
|
|
if p.Tasks[1].Artifact != "img" || p.Tasks[1].Module != ImageBuildModule {
|
|
t.Errorf("task = %+v, want the image on %s", p.Tasks[1], ImageBuildModule)
|
|
}
|
|
if p.NeedsToolchain(ImageBuildModule) {
|
|
t.Error("an image needs no toolchain")
|
|
}
|
|
}
|