mesh-controller/cmd/mesh-controller/found_wait_integration_test.go

//go:build integration

package main

import (
	"context"
	"strings"
	"testing"
	"time"

	"github.com/novox/mesh-controller/internal/conditions"
	"github.com/novox/mesh-controller/internal/inventory"
	"github.com/novox/mesh-controller/internal/link"
)

func TestAFixGoesThroughPastADirectoryFoundBefore(t *testing.T) {
	withTheGate(t) // the first-machine gate\'s own path (novox/hq ADR 0360 keeps it for earlier walks)
	for _, c := range []struct {
		name   string
		found  time.Duration // when the directory was found, against now
		passes bool
	}{
		{"found a day before the send", -24 * time.Hour, true},
		{"found by this send", time.Hour, false},
	} {
		t.Run(c.name, func(t *testing.T) {
			b := aBacklog(t)
			ctx := t.Context()
			inv := b.open.inventory
			releaseHeard = func(context.Context, *stores) (map[string]bool, error) {
				return map[string]bool{"anchor": true, "laptop": true}, nil
			}
			backlogFacts := gatherGateFacts
			gatherGateFacts = func(ctx context.Context, open *stores, component string) (gateFacts, error) {
				f, err := backlogFacts(ctx, open, component)
				// The used-as-found condition, raised after the send (its second statement): its own kind, never a
				// fault the gate reads as the build's.
				f.judged, f.openErr = true, nil
				f.open = append(f.open, conditions.Condition{Key: usedAsFoundKey("app", "anchor"), Kind: kindUsedAsFound,
					Subject: conditions.Subject{Scope: conditions.ScopeModule, ID: "app.anchor", Machine: "anchor"},
					Raised:  time.Now()})
				f.health = map[string]inventory.NodeHealth{}
				for _, n := range []string{"anchor", "laptop"} {
					f.health[n] = inventory.NodeHealth{Node: n, HeardAt: time.Now(), Resources: []inventory.ResourceHealth{
						{Module: "app", Resource: "app.web", Kind: "container", Target: "app", State: link.StateHealthy},
						foundDirectory("app", time.Now().Add(c.found)),
						{Module: "late", Resource: "late.web", Kind: "container", Target: "late", State: link.StateHealthy}}}
				}
				return f, err
			}
			wasWithin, wasEvery, wasBound := gateWithin, gateEvery, gateBound
			// The witness window is the node-engine's, from a start no test makes (novox/hq ADR 0351).
			wasWindow := gateWitnessWindow
			gateWitnessWindow = 0
			t.Cleanup(func() { gateWitnessWindow = wasWindow })
			t.Cleanup(func() { gateWithin, gateEvery, gateBound = wasWithin, wasEvery, wasBound })
			gateWithin, gateEvery, gateBound = time.Hour, 0, 300*time.Millisecond
			deadline := time.Now().Add(5 * time.Second)
			for time.Now().Before(deadline) {
				advancePlans(ctx, b.open)
				if p := b.release(t); p.State != inventory.PlanRolling {
					break
				}
				time.Sleep(20 * time.Millisecond)
			}
			p := b.release(t)
			v, found, err := inv.GateOf(ctx, "build-app-c2")
			if c.passes {
				if p.State != inventory.PlanDone || err != nil || !found || v.Verdict != inventory.GatePassed {
					t.Fatalf("the walk is %s (%s); app's verdict %+v: want the fix through", p.State, p.Note, v)
				}
				if !strings.Contains(v.Why+p.Note, "hand it over") {
					t.Errorf("the wait is not carried: verdict %q, walk %q", v.Why, p.Note)
				}
				return
			}
			if p.State == inventory.PlanDone {
				t.Fatalf("a directory this send found let the walk through: %s", p.Note)
			}
		})
	}
}

func TestADirectoryUsedAsFoundIsItsOwnCondition(t *testing.T) {
	withTheGate(t) // the first-machine gate\'s own path (novox/hq ADR 0360 keeps it for earlier walks)
	k, _ := withConditionsInMemory(t)
	ctx := t.Context()
	rs := map[string][]inventory.ResourceHealth{"notes": {foundDirectory("notes", time.Now().Add(-time.Hour))}}
	for i := 0; i < 2; i++ {
		if err := judgeModuleHealth(ctx, nil, k, "laptop", rs, map[string]int{"notes": i + 1}, time.Now()); err != nil {
			t.Fatal(err)
		}
	}
	open, _ := k.Open(ctx)
	var got *conditions.Condition
	for i, c := range open {
		if c.Key == usedAsFoundKey("notes", "laptop") {
			got = &open[i]
		}
		if c.Kind == kindModuleUnhealthy {
			t.Fatalf("raised as a fault: %+v", c)
		}
	}
	if got == nil || got.Resolver != conditions.ResolverOperator || got.Severity == conditions.Urgent ||
		!strings.Contains(got.Summary, "notes.data") {
		t.Fatalf("the condition: %+v", got)
	}
	// Long open is still not urgent: only a person can hand it over, and nothing is broken by the wait.
	if err := judgeModuleHealth(ctx, nil, k, "laptop", rs, map[string]int{"notes": 3}, time.Now().Add(48*time.Hour)); err != nil {
		t.Fatal(err)
	}
	open, _ = k.Open(ctx)
	for _, c := range open {
		if c.Key == usedAsFoundKey("notes", "laptop") && c.Severity == conditions.Urgent {
			t.Fatal("a directory used as found became urgent")
		}
	}
	if err := judgeModuleHealth(ctx, nil, k, "laptop", map[string][]inventory.ResourceHealth{}, nil, time.Now()); err != nil {
		t.Fatal(err)
	}
	open, _ = k.Open(ctx)
	for _, c := range open {
		if c.Key == usedAsFoundKey("notes", "laptop") {
			t.Fatal("not cleared once handed over")
		}
	}
}