mesh-controller/internal/catalogue/contributes_test.go

package catalogue

import (
	"encoding/json"
	"strings"
	"testing"
)

// The other half of an edge.
//
// `requires` says a thing must be there. It never said what to do with it — a web application
// requiring a reverse proxy has to say *which name, which port*, and there was nowhere to put
// that. The two modules that needed it most, the proxy and the VPN, went round the outside and
// opened a connection to the control plane's database, which is why every node held a credential
// to it permanently.

func published(module, host string, port int) Manifest {
	return Manifest{Module: module, Version: "1",
		Contributes: map[string]map[string]any{
			"reverse-proxy": {"host": host, "port": port},
		}}
}

func proxy() Manifest {
	return Manifest{Module: "traefik", Version: "1",
		Provides: []string{"reverse-proxy"},
		Receives: map[string]string{"reverse-proxy": "/etc/traefik/mesh.json"},
		Resources: []map[string]any{
			{"id": "up", "type": "service", "unit": "traefik", "state": "running",
				"restart-on": []any{ReceivedID("reverse-proxy")}},
		}}
}

// received digs the delivered contributions back out of a declaration.
func received(t *testing.T, out []map[string]any) []Contribution {
	t.Helper()
	for _, r := range out {
		if r["path"] != "/etc/traefik/mesh.json" {
			continue
		}
		body := r["content"].(string)
		var parsed struct {
			Requirement string         `json:"requirement"`
			Given       []Contribution `json:"given"`
		}
		if err := json.Unmarshal([]byte(body), &parsed); err != nil {
			t.Fatalf("the file the proxy is given is not readable: %v\n%s", err, body)
		}
		if parsed.Requirement != "reverse-proxy" {
			t.Fatalf("the file does not say what it is about: %q", parsed.Requirement)
		}
		return parsed.Given
	}
	t.Fatalf("the provider was given no file at all: %v", out)
	return nil
}

func TestTheFileTheProviderGetsIsMachineReadable(t *testing.T) {
	// It is written for a program, and the first version put a `//` header above the JSON — a
	// file that says "do not edit" to a person and fails to parse for the thing meant to read it.
	got, _ := Resolve(shelf(proxy(), published("board", "board", 8080)),
		[]string{"board"}, workstation(), nil)
	for _, r := range mustDeclare(t, got) {
		if r["path"] != "/etc/traefik/mesh.json" {
			continue
		}
		var any map[string]any
		if err := json.Unmarshal([]byte(r["content"].(string)), &any); err != nil {
			t.Fatalf("the file is not parseable: %v\n%s", err, r["content"])
		}
		if note, _ := any["generated"].(string); !strings.Contains(note, "do not edit") {
			// Inside the document rather than above it, so it reaches a person without
			// breaking the parse.
			t.Fatalf("the file does not say it is generated: %v", any["generated"])
		}
		return
	}
	t.Fatal("no received file")
}

func TestAModuleTellsItsProviderWhatItNeeds(t *testing.T) {
	got, err := Resolve(shelf(proxy(), published("board", "board", 8080)),
		[]string{"board"}, workstation(), nil)
	if err != nil {
		t.Fatal(err)
	}
	out, err := got.Declaration(Rendering{})
	if err != nil {
		t.Fatal(err)
	}
	given := received(t, out)
	if len(given) != 1 || given[0].From != "board" {
		t.Fatalf("the proxy was not told about board: %v", given)
	}
	if given[0].Values["host"] != "board" || given[0].Values["port"] != float64(8080) {
		t.Fatalf("the contribution did not survive: %v", given[0].Values)
	}
}

func TestContributingToSomethingIsRequiringIt(t *testing.T) {
	// Asking to be published means a publisher must exist. A module that had to say both would
	// eventually say one, and the failure would be a machine where nothing serves the route.
	got, err := Resolve(shelf(proxy(), published("board", "board", 8080)),
		[]string{"board"}, workstation(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if !strings.Contains(strings.Join(names(got), " "), "traefik") {
		t.Fatalf("contributing to reverse-proxy did not bring one in: %v", names(got))
	}
}

func TestNothingToContributeToIsRefused(t *testing.T) {
	_, err := Resolve(shelf(published("board", "board", 8080)),
		[]string{"board"}, workstation(), nil)
	if err == nil {
		t.Fatal("a module was published through a proxy that does not exist")
	}
	if !strings.Contains(err.Error(), "reverse-proxy") {
		t.Fatalf("the refusal does not name what is missing: %v", err)
	}
}

func TestEveryPublisherOnTheMachineIsInOneFile(t *testing.T) {
	got, err := Resolve(shelf(proxy(),
		published("board", "board", 8080),
		published("archive", "archive", 9000),
	), []string{"board", "archive"}, workstation(), nil)
	if err != nil {
		t.Fatal(err)
	}
	given := received(t, mustDeclare(t, got))
	if len(given) != 2 {
		t.Fatalf("the proxy was told about %d of 2: %v", len(given), given)
	}
	// Ordered by module, because this becomes a file and a file whose lines move about looks
	// changed when nothing changed — which would restart the proxy for ever.
	if given[0].From != "archive" || given[1].From != "board" {
		t.Fatalf("the order is not stable: %v", given)
	}
}

func TestAProviderWithNoConsumersStillGetsTheFile(t *testing.T) {
	// Empty rather than absent. A provider that finds no file cannot tell "nothing asked for me"
	// from "the mesh never wrote it", and those want completely different responses — the same
	// rule the host follows about a service that does not exist.
	got, err := Resolve(shelf(proxy()), []string{"traefik"}, workstation(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if given := received(t, mustDeclare(t, got)); len(given) != 0 {
		t.Fatalf("got %v", given)
	}
}

func TestTheProviderCanReloadWhenTheRoutesChange(t *testing.T) {
	// A proxy that got a new route and did not reload is a route that silently does not work.
	// The same fault the private network had when a peer list changed under a running interface,
	// which is why the received file has a name a module can point at.
	got, _ := Resolve(shelf(proxy(), published("board", "board", 8080)),
		[]string{"board"}, workstation(), nil)
	out := mustDeclare(t, got)
	for _, r := range out {
		if r["type"] != "service" {
			continue
		}
		reflects, ok := r["restart-on"].([]any)
		if !ok || len(reflects) != 1 {
			t.Fatalf("the proxy does not reflect anything: %v", r)
		}
		if reflects[0] != "traefik."+ReceivedID("reverse-proxy") {
			t.Fatalf("it reflects %v, which is not the file it was given", reflects[0])
		}
		return
	}
	t.Fatal("no service in the declaration")
}

func TestARouteCanBeSetPerMesh(t *testing.T) {
	// The hostname is exactly the kind of thing that differs between one mesh and the next. A
	// module whose route could not be set would have to be edited to be reused anywhere.
	got, _ := Resolve(shelf(proxy(), published("board", "board", 8080)),
		[]string{"board"}, workstation(), nil)
	out, err := got.Declaration(Rendering{Settings: SettingsBy{
		"board": {{From: "the mesh", Values: map[string]any{"host": "dashboard"}}},
	}})
	if err != nil {
		t.Fatal(err)
	}
	given := received(t, out)
	if given[0].Values["host"] != "dashboard" {
		t.Fatalf("the setting did not reach the route: %v", given[0].Values)
	}
	if given[0].Values["port"] != float64(8080) {
		t.Fatalf("setting the host dropped the port: %v", given[0].Values)
	}
}

func TestReceivingWhatYouDoNotProvideIsRefused(t *testing.T) {
	// It would create a file nobody ever writes to, on a machine where nothing asked for it.
	_, err := ParseManifest([]byte(`{"module":"traefik","version":"1",
		"receives":{"reverse-proxy":"/etc/traefik/mesh.json"}}`))
	if err == nil {
		t.Fatal("a module received contributions to something it does not provide")
	}
	if !strings.Contains(err.Error(), "does not provide") {
		t.Fatalf("unhelpful refusal: %v", err)
	}
}

func TestAnEmptyContributionIsRefused(t *testing.T) {
	// Either a mistake or a requirement written the long way round, and both are better said.
	_, err := ParseManifest([]byte(`{"module":"board","version":"1",
		"contributes":{"reverse-proxy":{}}}`))
	if err == nil {
		t.Fatal("a module contributed nothing and was accepted")
	}
	if !strings.Contains(err.Error(), "require it") {
		t.Fatalf("the refusal does not say what to do instead: %v", err)
	}
}