mesh-controller/cmd/mesh-controller/seats_test.go

package main

import (
	"context"
	"strings"
	"testing"

	"git.novox.be/novox/mesh-sdk/go/catalogue"
)

// The overview of what a mesh has (novox/hq ADR 0110).

func TestEverySeatIsListedIncludingTheOnesNobodyHolds(t *testing.T) {
	// An unheld seat is an answer — "this mesh has no forge" — so it is listed rather than omitted.
	rows, _ := seatsHeld(catalogue.Seats(), []catalogue.Held{
		{Claim: "mesh-store", Scope: catalogue.ScopeMesh, Node: "anchor", Module: "postgres"},
	})
	if len(rows) != len(catalogue.Seats()) {
		t.Fatalf("%d seats listed of %d", len(rows), len(catalogue.Seats()))
	}
	for _, r := range rows {
		switch r.Seat {
		case "mesh-store":
			if len(r.Holders) != 1 || r.Holders[0].Module != "postgres" || r.Holders[0].Node != "anchor" {
				t.Errorf("mesh-store is held by %+v", r.Holders)
			}
			if r.Delivers != "postgres-database" {
				t.Errorf("mesh-store does not say what it delivers: %q", r.Delivers)
			}
		case "git":
			if len(r.Holders) != 0 {
				t.Errorf("git is held by %+v in a mesh with no forge", r.Holders)
			}
		}
	}
}

func TestANodeSeatListsEveryMachineHoldingIt(t *testing.T) {
	rows, _ := seatsHeld(catalogue.Seats(), []catalogue.Held{
		{Claim: "node-packet-filter", Scope: catalogue.ScopeNode, Node: "node2", Module: "nftables"},
		{Claim: "node-packet-filter", Scope: catalogue.ScopeNode, Node: "anchor", Module: "nftables"},
		// Resolved twice, reported once: a machine is one holder however many passes saw it.
		{Claim: "node-packet-filter", Scope: catalogue.ScopeNode, Node: "anchor", Module: "nftables"},
	})
	for _, r := range rows {
		if r.Seat != "node-packet-filter" {
			continue
		}
		if len(r.Holders) != 2 || r.Holders[0].Node != "anchor" || r.Holders[1].Node != "node2" {
			t.Fatalf("the packet filter is held by %+v", r.Holders)
		}
		return
	}
	t.Fatal("the packet filter is not listed")
}

func TestAClaimOutsideTheSetIsShownNotHidden(t *testing.T) {
	// A manifest registered before the set closed can still hold one. Leaving it out would make
	// the overview quietly incomplete, which is the one thing it may not be.
	_, outside := seatsHeld(catalogue.Seats(), []catalogue.Held{
		{Claim: "the-controller", Scope: catalogue.ScopeMesh, Node: "anchor", Module: "mesh-controller"},
	})
	if len(outside) != 1 || outside[0].Claim != "the-controller" {
		t.Fatalf("a claim outside the set was not shown: %+v", outside)
	}
}

// A kinded bench is not handed over by `seat`: each kind is held by its claim (novox/hq ADR 0259).
func TestAKindedBenchIsNotHandedOver(t *testing.T) {
	for _, bench := range []string{"channel", "intake"} {
		err := handOver(context.Background(), bench, "anchor/telegram", false)
		if err == nil || !strings.Contains(err.Error(), "is a kinded bench") {
			t.Errorf("%s: %v", bench, err)
		}
	}
}

// The listing shows each seat's paths, and the seat a path steps back for (novox/hq ADR 0287).
func TestTheSeatsListingShowsEachSeatsPaths(t *testing.T) {
	rows, _ := seatsHeld(catalogue.Seats(), nil)
	got := map[string]string{}
	for _, r := range rows {
		got[r.Seat] = seatPathsText(r.Paths)
	}
	for seat, want := range map[string]string{
		"node-hostname":      "/etc/hosts, /etc/hostname",
		"node-uplink":        "/etc/resolv.conf (steps back for node-resolver)",
		"node-resolver":      "/etc/resolv.conf",
		"node-packet-filter": "—",
	} {
		if got[seat] != want {
			t.Errorf("%s lists its paths as %q, not %q", seat, got[seat], want)
		}
	}
}

// 1718/AC2: a manifest claiming node-files that serves upload and download passes the controller's module
// check, judged by the mesh-sdk it vendors; a verb outside the contract is still refused.
func TestAFilesHolderServingUploadAndDownloadCanHoldTheSeat(t *testing.T) {
	seat, ok := catalogue.SeatNamed(catalogue.FilesSeat)
	if !ok {
		t.Fatal("node-files is not a seat")
	}
	serves := []string{"upload", "download"}
	for _, v := range seat.Serves {
		if v.Name != "upload" && v.Name != "download" {
			serves = append(serves, v.Name)
		}
	}
	holder := catalogue.Manifest{Module: "mesh-files", Version: "1", Claims: []catalogue.Claim{{
		Name: catalogue.FilesSeat, Scope: catalogue.ScopeNode, Serves: serves}}}
	if err := catalogue.CanHold(holder, seat); err != nil { // 1718/AC2
		t.Fatalf("a holder serving upload and download is refused: %v", err)
	}
	holder.Claims[0].Serves = append(append([]string{}, serves...), "teleport")
	if err := catalogue.CanHold(holder, seat); err == nil || !strings.Contains(err.Error(), "does not promise") {
		t.Fatalf("a verb outside the contract must be refused with 'does not promise': %v", err)
	}
}