85 lines
3.6 KiB
Go
85 lines
3.6 KiB
Go
//go:build integration
|
|
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/asks"
|
|
"github.com/novox/mesh-controller/internal/broker"
|
|
"github.com/novox/mesh-controller/internal/catalogue"
|
|
"github.com/novox/mesh-controller/internal/identity"
|
|
"github.com/novox/mesh-controller/internal/link"
|
|
)
|
|
|
|
// aForgeAndABuildSeat gives a test what a real ask of a build needs: the forge holding the git seat, assigned to anchor, so
|
|
// the clone URL composes; the identity store; the build seat's queue on a real bus; and the environment of the serving controller, which is
|
|
// never the controller's terminal (a verb's, in effect: startedAtTheTerminal is false).
|
|
func aForgeAndABuildSeat(t *testing.T, open *stores) *broker.JetStream {
|
|
t.Helper()
|
|
js, _ := aBuildQueue(t)
|
|
// The ask signs what it sends with the controller's identity, as the serving controller does.
|
|
identity.ForTest(t)
|
|
forge, err := catalogue.ParseManifest([]byte(`{"module":"gitea","version":"1",
|
|
"claims":[{"name":"git","scope":"mesh"}],"provides":[{"name":"git","scope":"mesh"}],
|
|
"serves":{"git":{"scheme":"http","port":3000}}}`))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
register(t, open, forge)
|
|
if _, err := assign(t.Context(), open, "anchor", "gitea"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Setenv(servedVar, "1")
|
|
return js
|
|
}
|
|
|
|
// 1146/AC9, through the real ask (askABuild, buildOneAsked, verbMayAsk) and a real bus: the first build of a module a
|
|
// merge adds on the operator's Approve is queued on the build seat; the same ask without that warrant, and the warrant's
|
|
// ask for a path the merge does not hold, are refused by the guard of a build through a verb.
|
|
func TestTheApprovedFirstBuildPassesTheGuardOfAVerbAndIsQueued(t *testing.T) {
|
|
const head, commit = "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1", "0177ea7a00000000"
|
|
open := aMesh(t)
|
|
ctx := t.Context()
|
|
js := aForgeAndABuildSeat(t, open)
|
|
|
|
a := aDeliveryMergeOf(t, head, map[string]string{"novox/mesh-delivery@a1a1a1a1a1a1": head})
|
|
wasKept, wasAsk := keptDeliveryMerge, routerAskOf
|
|
keptDeliveryMerge = func(context.Context, string, string, int, string) (deliveryMerge, bool, error) {
|
|
return a.merge, true, nil
|
|
}
|
|
routerAskOf = func(context.Context, catalogueReader, string, string) (*asks.Ask, *asks.Warrant, error) {
|
|
return &a.ask, &a.warrant, nil
|
|
}
|
|
t.Cleanup(func() { keptDeliveryMerge, routerAskOf = wasKept, wasAsk })
|
|
|
|
// Without the warrant the guard refuses, whatever the repository holds.
|
|
_, err := askABuild(ctx, buildSource{Repository: "novox/mesh-delivery", Seat: "git"}, "", "main")
|
|
var policy *heldAtTheTerminal
|
|
if !errors.As(err, &policy) {
|
|
t.Fatalf("1146/AC9: a first build asked without the warrant was not refused: %v", err)
|
|
}
|
|
// And a path the merge does not hold is refused on the warrant.
|
|
warranted := withFirstBuildWarrant(ctx, "novox/mesh-delivery", []string{""}, "the Approve")
|
|
if _, err := askABuild(warranted, buildSource{Repository: "novox/mesh-delivery", Seat: "git"}, "other", "main"); !errors.As(err, &policy) {
|
|
t.Fatalf("1146/AC9: the warrant covered a path the merge does not hold: %v", err)
|
|
}
|
|
|
|
m := link.SourceMoved{Owner: "novox", Repo: "mesh-delivery", Base: "main", HeadSHA: head, Commit: commit, Number: 7,
|
|
MergedAt: time.Now().Add(-time.Hour).UTC().Format(time.RFC3339Nano), Paths: []string{"module.json", "main.go"},
|
|
ModuleDirs: []string{"."}, ModuleDirsSaid: true}
|
|
if err := (following{open: open}).SourceMoved(ctx, m); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
queue, err := link.ReadQueue(ctx, js, link.TheBuildMachine)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(queue.Asks) != 1 {
|
|
t.Fatalf("1146/AC9: the build queue holds %+v, want the one first build", queue)
|
|
}
|
|
}
|