mesh-controller/cmd/mesh-controller/issue201_integration_test.go

//go:build integration

package main

import (
	"context"
	"encoding/json"
	"strings"
	"testing"
	"time"

	"git.novox.be/novox/mesh-sdk/go/catalogue"
	"github.com/novox/mesh-controller/internal/inventory"
	"github.com/novox/mesh-controller/internal/lease"
)

func core201(t *testing.T) *stores {
	t.Helper()
	open := aMesh(t)
	ctx := t.Context()
	inv := open.inventory
	old, now := time.Now().Add(-2*time.Hour), time.Now().Add(-time.Minute)
	record := func(commit string, asked time.Time) inventory.Build {
		manifest, _ := json.Marshal(catalogue.Manifest{Module: "mesh-controller", Version: "1"})
		b := inventory.Build{ID: "build-mesh-controller-" + commit, Module: "mesh-controller", Commit: commit,
			Repository: "novox/mesh-controller", Manifest: manifest, Asked: asked, At: asked,
			Made: []inventory.Artifact{{Name: "x", Kind: "bundle", Reference: "sha256:" + commit + "0000000000000000"}}}
		if err := inv.RecordBuild(ctx, b); err != nil {
			t.Fatal(err)
		}
		return b
	}
	before := record("c1aaaaaaaaaa", old)
	if err := inv.RecordGate(ctx, inventory.GateVerdict{Build: before.ID, Module: "mesh-controller", Commit: before.Commit,
		Machines: []string{"anchor"}, Verdict: inventory.GatePassed}); err != nil {
		t.Fatal(err)
	}
	record("c2bbbbbbbbbb", now)
	if err := inv.RegisterModule(ctx, catalogue.Manifest{Module: "mesh-controller", Version: "1"}, inventory.Source{
		Repository: "novox/mesh-controller", BuiltFrom: "c2bbbbbbbbbb", Head: "c2bbbbbbbbbb", Asked: now}); err != nil {
		t.Fatal(err)
	}
	if _, err := inv.Assign(ctx, "anchor", "mesh-controller"); err != nil {
		t.Fatal(err)
	}
	if err := inv.RecordSent(ctx, nodeID(t, open, "anchor"), "d-anchor", map[string]string{"mesh-controller": "c2bbbbbbbbbb"}); err != nil {
		t.Fatal(err)
	}
	if err := inv.RestoreModule(ctx, before); err != nil {
		t.Fatal(err)
	}
	wasMoves := machineMoves
	machineMoves = func(ctx context.Context, open *stores, f moveFacts, node string, all bool) ([]inventory.CarriedMove, error) {
		modules, err := open.inventory.Assigned(ctx, node)
		if err != nil {
			return nil, err
		}
		sent, known, err := open.inventory.SentBuilds(ctx, node)
		if err != nil {
			return nil, err
		}
		return f.moves(node, modules, sent, known, all), nil
	}
	t.Cleanup(func() { machineMoves = wasMoves })
	return open
}

func TestReplay201(t *testing.T) {
	open := core201(t)
	ctx := t.Context()
	k, _ := withConditionsInMemory(t)

	judged := withScope(ctx, sendScope{judged: map[string]bool{"anchor": true}})
	if kept, err := ungatedIn(judged, open, []string{"anchor"}, ""); err != nil || len(kept) != 1 {
		t.Fatalf("a plan's send to the machine is made, the rest of it with it: %v %v", kept, err)
	}
	keeps, err := recordedKept(keepingRecorded(judged), open, "anchor")
	if err != nil || keeps["mesh-controller"] != "c2bbbbbbbbbb" {
		t.Fatalf("the send keeps the newer controller there: %v %v", keeps, err)
	}
	shelf := map[string]catalogue.Manifest{"mesh-controller": {Module: "mesh-controller", Version: "old"}}
	if err := applyKept(keepingRecorded(judged), open, "anchor", keeps, shelf); err != nil || shelf["mesh-controller"].Version != "1" {
		t.Fatalf("the send composes the kept build's manifest: %+v %v", shelf, err)
	}
	key := coreDowngradeObservation(lease.ComponentController, "anchor", "").Key()
	if c, found, err := k.Get(ctx, key); err != nil || !found || !strings.Contains(c.Summary, "c2bbbbbb") {
		t.Fatalf("the condition %s is raised, saying the build kept: %+v %v %v", key, c, found, err)
	}

	putBack := keepingRecorded(withScope(ctx, sendScope{modules: map[string]bool{"mesh-controller": true}, puttingBack: true}))
	if keeps, err := recordedKept(putBack, open, "anchor"); err != nil || len(keeps) != 0 {
		t.Fatalf("the gate's own put-back of the controller carries it back: %v %v", keeps, err)
	}

	settleCoreDowngrades(ctx, open.inventory, "anchor", map[string]string{"mesh-controller": "c2bbbbbbbbbb"})
	if _, found, _ := k.Get(ctx, key); !found {
		t.Fatal("a send that kept the newer controller cleared the condition")
	}
	settleCoreDowngrades(ctx, open.inventory, "anchor", map[string]string{"mesh-controller": "c1aaaaaaaaaa"})
	if _, found, _ := k.Get(ctx, key); found {
		t.Fatal("a send carrying the mesh's record — a person's push — leaves the condition open")
	}
}

func TestARollbackWhoseSendWasRefusedIsCompletedByTheNextSend(t *testing.T) {
	open := core201(t)
	ctx := t.Context()
	k, _ := withConditionsInMemory(t)
	if err := open.inventory.RecordGate(ctx, inventory.GateVerdict{Build: "build-mesh-controller-c2bbbbbbbbbb",
		Module: "mesh-controller", Commit: "c2bbbbbbbbbb", Previous: "c1aaaaaaaaaa", Machines: []string{"anchor"},
		Verdict: inventory.GateFailed, Rollback: inventory.NotRolledBack}); err != nil {
		t.Fatal(err)
	}
	healer := withScope(ctx, sendScope{})
	if kept, err := ungatedIn(healer, open, []string{"anchor"}, ""); err != nil || len(kept) != 1 {
		t.Fatalf("the healer's send is made: %v %v", kept, err)
	}
	if keeps, err := recordedKept(keepingRecorded(healer), open, "anchor"); err != nil || len(keeps) != 0 {
		t.Fatalf("the failed controller was kept over the build put back: %v %v", keeps, err)
	}
	if open, _ := k.Open(ctx); len(open) != 0 {
		t.Fatalf("a completed put-back raised a condition: %+v", open)
	}
}

func TestAGateJudgesTheOtherMovesBesideAKeptCore(t *testing.T) {
	open := core201(t)
	ctx := t.Context()
	withConditionsInMemory(t)
	inv := open.inventory
	old, now := time.Now().Add(-2*time.Hour), time.Now().Add(-time.Minute)
	for _, b := range []struct {
		commit string
		at     time.Time
	}{{"a1aaaaaaaaaa", old}, {"a2bbbbbbbbbb", now}} {
		manifest, _ := json.Marshal(catalogue.Manifest{Module: "app", Version: "1"})
		if err := inv.RecordBuild(ctx, inventory.Build{ID: "build-app-" + b.commit, Module: "app", Commit: b.commit,
			Repository: "novox/mesh-catalog", Path: "modules/app", Manifest: manifest, Asked: b.at, At: b.at,
			Made: []inventory.Artifact{{Name: "x", Kind: "bundle", Reference: "sha256:app-" + b.commit}}}); err != nil {
			t.Fatal(err)
		}
		if err := inv.RegisterModule(ctx, catalogue.Manifest{Module: "app", Version: "1"}, inventory.Source{
			Repository: "novox/mesh-catalog", Seat: "git", Path: "modules/app", BuiltFrom: b.commit, Head: b.commit,
			Asked: b.at}); err != nil {
			t.Fatal(err)
		}
	}
	if _, err := inv.Assign(ctx, "anchor", "app"); err != nil {
		t.Fatal(err)
	}
	if err := inv.RecordSent(ctx, nodeID(t, open, "anchor"), "d-anchor-2",
		map[string]string{"mesh-controller": "c2bbbbbbbbbb", "app": "a1aaaaaaaaaa"}); err != nil {
		t.Fatal(err)
	}
	// The send as it is made: the controller kept at c2, the app moved to the record.
	wasSend := sendRollout
	sendRollout = func(ctx context.Context, open *stores, names []string) ([]string, error) {
		return names, open.inventory.RecordSent(ctx, nodeID(t, open, "anchor"), "d-anchor-3",
			map[string]string{"mesh-controller": "c2bbbbbbbbbb", "app": "a2bbbbbbbbbb"})
	}
	t.Cleanup(func() { sendRollout = wasSend })

	moves, sent, _, err := gatedSend(ctx, open, "anchor", nil)
	if err != nil || len(sent) != 1 {
		t.Fatalf("the gated send is made: %v %v", sent, err)
	}
	if len(moves) != 1 || moves[0].Module != "app" || moves[0].To != "a2bbbbbbbbbb" {
		t.Fatalf("the gate judges the app's move and not the kept controller: %+v", moves)
	}
	builds, _, err := inv.SentBuilds(ctx, "anchor")
	if err != nil {
		t.Fatal(err)
	}
	g := &inventory.PlanGate{Carried: moves}
	f := gateFacts{commits: judgedCommits(g, nil), sentBuilds: map[string]map[string]string{"anchor": builds}}
	for _, m := range []string{"app", "mesh-controller"} {
		if why, superseded := f.supersededOn(m, "anchor"); superseded {
			t.Fatalf("the gate is superseded by its own send: %s", why)
		}
	}
}