mesh-controller/internal/catalogue/delivery_seat_test.go

package catalogue

import (
	"reflect"
	"strings"
	"testing"
)

// The delivery seat answers "what did the mesh's checks say of this pull request?" as a verb of its own,
// `checks` (novox/hq ADR 0239): read by repository and a pull request's number or a commit.
func TestTheDeliverySeatPromisesChecks(t *testing.T) {
	seat, ok := SeatNamed(DeliverySeat)
	if !ok {
		t.Fatal("the delivery seat is not in the set")
	}
	var checks *Verb
	for i := range seat.Serves {
		if seat.Serves[i].Name == "checks" {
			checks = &seat.Serves[i]
		}
	}
	if checks == nil {
		t.Fatalf("the delivery seat promises %v and not checks", VerbNames(seat.Serves))
	}
	props, _ := checks.Input["properties"].(map[string]any)
	for _, arg := range []string{"repository", "number", "commit"} {
		if _, has := props[arg]; !has {
			t.Errorf("checks takes no %q", arg)
		}
	}
	if req, _ := checks.Input["required"].([]string); !reflect.DeepEqual(req, []string{"repository"}) {
		t.Errorf("checks requires %v, wanted only the repository", req)
	}

	// Added after the seat's holder shipped, it is optional: the holder serving the ten verbs before it still
	// holds the seat, and one serving all eleven does too — so the controller and the catalogue can move in
	// either order, and no check of the catalogue fails on a module nobody touched between the two.
	if !checks.Optional {
		t.Fatal("checks is a condition of holding before its holder serves it")
	}
	var before []string
	for _, v := range VerbNames(seat.Serves) {
		if v != "checks" {
			before = append(before, v)
		}
	}
	m := Manifest{Module: "mesh-delivery", Claims: []Claim{{Name: DeliverySeat, Scope: ScopeMesh, Serves: before}}}
	if err := CanHold(m, seat); err != nil {
		t.Fatalf("a holder without checks yet: %v", err)
	}
	m.Claims[0].Serves = VerbNames(seat.Serves)
	if err := CanHold(m, seat); err != nil {
		t.Fatalf("a holder serving every verb: %v", err)
	}
	// Every other verb is still a condition of holding.
	m.Claims[0].Serves = append([]string{"checks"}, before[1:]...)
	if err := CanHold(m, seat); err == nil || !strings.Contains(err.Error(), before[0]) {
		t.Fatalf("a holder without %s: %v", before[0], err)
	}
}

// The seat retires history on a person's word (novox/hq issue 313): `retire-history`, with why, one delivery by
// id or every held one, dry to see first. Added after the holder shipped, it is optional, so the holder that
// does not serve it yet still holds the seat, and one that does is not refused for a verb the seat lacks.
func TestTheDeliverySeatPromisesRetireHistoryOptionally(t *testing.T) {
	seat, _ := SeatNamed(DeliverySeat)
	var retire *Verb
	for i := range seat.Serves {
		if seat.Serves[i].Name == "retire-history" {
			retire = &seat.Serves[i]
		}
	}
	if retire == nil || !retire.Optional {
		t.Fatalf("the delivery seat promises %v, retire-history optionally", VerbNames(seat.Serves))
	}
	props, _ := retire.Input["properties"].(map[string]any)
	for _, arg := range []string{"why", "id", "repository", "dry"} {
		if _, has := props[arg]; !has {
			t.Errorf("retire-history takes no %q", arg)
		}
	}
	if req, _ := retire.Input["required"].([]string); !reflect.DeepEqual(req, []string{"why"}) {
		t.Errorf("retire-history requires %v, wanted only why", req)
	}
	var without []string
	for _, v := range VerbNames(seat.Serves) {
		if v != "retire-history" {
			without = append(without, v)
		}
	}
	m := Manifest{Module: "mesh-delivery", Claims: []Claim{{Name: DeliverySeat, Scope: ScopeMesh, Serves: without}}}
	if err := CanHold(m, seat); err != nil {
		t.Fatalf("a holder without retire-history yet: %v", err)
	}
	m.Claims[0].Serves = VerbNames(seat.Serves)
	if err := CanHold(m, seat); err != nil {
		t.Fatalf("a holder serving retire-history: %v", err)
	}
}

// The seat says delivery times (novox/hq ADR 0282, issue 382): `times`, over some days or for one delivery. Added
// after the holder shipped, it is optional, so the holder that does not serve it yet still holds the seat, and one
// that does is not refused for a verb the seat lacks.
func TestTheDeliverySeatPromisesTimesOptionally(t *testing.T) {
	seat, _ := SeatNamed(DeliverySeat)
	var times *Verb
	for i := range seat.Serves {
		if seat.Serves[i].Name == "times" {
			times = &seat.Serves[i]
		}
	}
	if times == nil || !times.Optional {
		t.Fatalf("the delivery seat promises %v, times optionally", VerbNames(seat.Serves))
	}
	props, _ := times.Input["properties"].(map[string]any)
	for _, arg := range []string{"days", "id"} {
		if _, has := props[arg]; !has {
			t.Errorf("times takes no %q", arg)
		}
	}
	var without []string
	for _, v := range VerbNames(seat.Serves) {
		if v != "times" {
			without = append(without, v)
		}
	}
	m := Manifest{Module: "mesh-delivery", Claims: []Claim{{Name: DeliverySeat, Scope: ScopeMesh, Serves: without}}}
	if err := CanHold(m, seat); err != nil {
		t.Fatalf("a holder without times yet: %v", err)
	}
	m.Claims[0].Serves = VerbNames(seat.Serves)
	if err := CanHold(m, seat); err != nil {
		t.Fatalf("a holder serving times: %v", err)
	}
}