Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

32.3 KB
Raw Blame
package unifiedresources

import (
	"testing"
	"time"

	"github.com/rcourtman/pulse-go-rewrite/internal/models"
)

func TestResolveResource_NilReadState(t *testing.T) {
	loc := ResolveResource(nil, "anything")
	if loc.Found {
		t.Fatal("expected not found for nil ReadState")
	}
}

func TestResolveResource_TrimmedLookupName(t *testing.T) {
	rr := NewRegistry(nil)
	rr.IngestSnapshot(models.StateSnapshot{
		Hosts: []models.Host{{ID: "host1", Hostname: "myserver", Platform: "linux"}},
	})

	loc := ResolveResource(rr, "  myserver  ")
	if !loc.Found || loc.ResourceType != "agent" {
		t.Fatalf("expected trimmed lookup to find agent, got found=%v type=%q", loc.Found, loc.ResourceType)
	}
	if loc.Name != "myserver" {
		t.Fatalf("expected canonical name myserver, got %q", loc.Name)
	}
	if loc.TargetID != "host1" {
		t.Fatalf("expected TargetID=host1, got %q", loc.TargetID)
	}
}

func TestResolveResource_WhitespaceOnlyInput(t *testing.T) {
	loc := ResolveResource(nil, "   ")
	if loc.Found {
		t.Fatal("expected whitespace-only lookup to be not found")
	}
	if loc.Name != "" {
		t.Fatalf("expected empty normalized name, got %q", loc.Name)
	}
}

func TestResolveResource_Node(t *testing.T) {
	rr := NewRegistry(nil)
	rr.IngestSnapshot(models.StateSnapshot{
		Nodes: []models.Node{{ID: "n1", Name: "pve-node"}},
	})
	loc := ResolveResource(rr, "pve-node")
	if !loc.Found {
		t.Fatal("expected node to be found")
	}
	if loc.ResourceType != "node" {
		t.Fatalf("expected node type, got %q", loc.ResourceType)
	}
	if loc.TargetHost != "pve-node" {
		t.Fatalf("expected target_host pve-node, got %q", loc.TargetHost)
	}
}

func TestResolveResource_VM(t *testing.T) {
	rr := NewRegistry(nil)
	rr.IngestSnapshot(models.StateSnapshot{
		VMs: []models.VM{{ID: "vm-1", Name: "alpha", VMID: 101, Node: "node1"}},
	})
	loc := ResolveResource(rr, "alpha")
	if !loc.Found || loc.ResourceType != "vm" {
		t.Fatalf("expected vm, got found=%v type=%q", loc.Found, loc.ResourceType)
	}
	if loc.VMID != 101 || loc.Node != "node1" {
		t.Fatalf("expected VMID=101 Node=node1, got VMID=%d Node=%q", loc.VMID, loc.Node)
	}
}

func TestResolveResource_Container(t *testing.T) {
	rr := NewRegistry(nil)
	rr.IngestSnapshot(models.StateSnapshot{
		Containers: []models.Container{{ID: "lxc-1", Name: "beta", VMID: 201, Node: "node1", Type: "lxc"}},
	})
	loc := ResolveResource(rr, "beta")
	if !loc.Found || loc.ResourceType != "system-container" {
		t.Fatalf("expected system-container, got found=%v type=%q", loc.Found, loc.ResourceType)
	}
	if loc.VMID != 201 {
		t.Fatalf("expected VMID=201, got %d", loc.VMID)
	}
}

func TestResolveResource_DockerContainer(t *testing.T) {
	rr := NewRegistry(nil)
	rr.IngestSnapshot(models.StateSnapshot{
		Containers: []models.Container{{ID: "lxc-1", Name: "dock1", VMID: 100, Node: "node1", Type: "lxc"}},
		DockerHosts: []models.DockerHost{{
			ID:       "dock1",
			Hostname: "dock1",
			Containers: []models.DockerContainer{{
				ID:    "cid1",
				Name:  "homepage",
				State: "running",
			}},
		}},
	})
	loc := ResolveResource(rr, "homepage")
	if !loc.Found || loc.ResourceType != "app-container" {
		t.Fatalf("expected app-container, got found=%v type=%q", loc.Found, loc.ResourceType)
	}
	if loc.DockerHostName != "dock1" {
		t.Fatalf("expected docker host dock1, got %q", loc.DockerHostName)
	}
	if loc.DockerHostType != "system-container" {
		t.Fatalf("expected docker host type system-container, got %q", loc.DockerHostType)
	}
	if loc.DockerHostVMID != 100 {
		t.Fatalf("expected docker host VMID 100, got %d", loc.DockerHostVMID)
	}
	// TargetHost must be rewritten to the LXC name for command routing.
	if loc.TargetHost != "dock1" {
		t.Fatalf("expected target_host rewritten to LXC name dock1, got %q", loc.TargetHost)
	}
}

func TestResolveResource_DockerContainerTargetHostRewrite(t *testing.T) {
	// Docker container lookup must rewrite TargetHost to the backing LXC name.
	// Use Docker host ID matching (not hostname) to verify the rewrite path.
	rr := NewRegistry(nil)
	rr.IngestSnapshot(models.StateSnapshot{
		Containers: []models.Container{{ID: "lxc-1", Name: "docker-host-lxc", VMID: 100, Node: "node1", Type: "lxc"}},
		DockerHosts: []models.DockerHost{{
			ID:       "docker-host-lxc",
			Hostname: "docker-host-lxc",
			Containers: []models.DockerContainer{{
				ID:    "cid1",
				Name:  "myapp",
				State: "running",
			}},
		}},
	})
	loc := ResolveResource(rr, "myapp")
	if !loc.Found || loc.ResourceType != "app-container" {
		t.Fatalf("expected app-container, got found=%v type=%q", loc.Found, loc.ResourceType)
	}
	if loc.TargetHost != "docker-host-lxc" {
		t.Fatalf("expected target_host rewritten to LXC name, got %q", loc.TargetHost)
	}
	if loc.DockerHostType != "system-container" {
		t.Fatalf("expected system-container, got %q", loc.DockerHostType)
	}

	// Docker HOST lookup must NOT rewrite TargetHost.
	locHost := ResolveResource(rr, "docker-host-lxc")
	if !locHost.Found || locHost.ResourceType != "docker-host" || locHost.DockerHostType != "system-container" || locHost.DockerHostVMID != 100 {
		t.Fatalf("expected the registered Docker host source reference to keep its current guest parent, got %+v", locHost)
	}
}

func TestResolveResource_DockerHost(t *testing.T) {
	rr := NewRegistry(nil)
	rr.IngestSnapshot(models.StateSnapshot{
		DockerHosts: []models.DockerHost{{
			ID:       "standalone1",
			Hostname: "standalone1",
		}},
	})
	loc := ResolveResource(rr, "standalone1")
	if !loc.Found || loc.ResourceType != "docker-host" {
		t.Fatalf("expected docker-host, got found=%v type=%q", loc.Found, loc.ResourceType)
	}
	if loc.DockerHostType != "standalone" {
		t.Fatalf("expected standalone, got %q", loc.DockerHostType)
	}
}

func TestResolveResource_TrueNASAppDoesNotUseDockerRouting(t *testing.T) {
	rr := newTrueNASAppRegistryFixture()

	loc := ResolveResource(rr, "Nextcloud")
	if !loc.Found || loc.ResourceType != "app-container" {
		t.Fatalf("expected TrueNAS app-container, got found=%v type=%q", loc.Found, loc.ResourceType)
	}
	if loc.TargetHost != "truenas-main" {
		t.Fatalf("expected target host truenas-main, got %q", loc.TargetHost)
	}
	if loc.DockerHostName != "" || loc.DockerHostType != "" {
		t.Fatalf("expected TrueNAS app to avoid docker routing, got docker_host=%q type=%q", loc.DockerHostName, loc.DockerHostType)
	}
}

func TestResolveResource_VMwareStorage(t *testing.T) {
	rr := NewRegistry(nil)
	now := time.Now().UTC()
	rr.IngestRecords(SourceVMware, []IngestRecord{{
		SourceID: "vc-1:datastore:datastore-11",
		Resource: Resource{
			Type:       ResourceTypeStorage,
			Name:       "nvme-primary",
			Status:     StatusOnline,
			LastSeen:   now,
			UpdatedAt:  now,
			ParentName: "Lab VC",
			Storage:    &StorageMeta{Type: "vmfs"},
			VMware: &VMwareData{
				ConnectionID:    "vc-1",
				ConnectionName:  "Lab VC",
				ManagedObjectID: "datastore-11",
				EntityType:      "datastore",
			},
		},
	}})

	loc := ResolveResource(rr, "nvme-primary")
	if !loc.Found || loc.ResourceType != "storage" {
		t.Fatalf("expected storage resource, got found=%v type=%q", loc.Found, loc.ResourceType)
	}
	if loc.TargetID != "Lab VC" || loc.TargetHost != "Lab VC" {
		t.Fatalf("expected VMware storage target to route through Lab VC, got %+v", loc)
	}

	resolved := ResolveResourceContext(rr, "nvme-primary")
	if resolved.Resource == nil {
		t.Fatal("expected resolved VMware storage resource")
	}
	if resolved.Resource.Type != ResourceTypeStorage {
		t.Fatalf("expected storage resource payload, got %q", resolved.Resource.Type)
	}
	if resolved.Resource.VMware == nil || resolved.Resource.VMware.ManagedObjectID != "datastore-11" {
		t.Fatalf("expected VMware datastore metadata, got %+v", resolved.Resource.VMware)
	}
}

func TestResolveResourceContext_TrueNASAppUsesCanonicalAppContainerSet(t *testing.T) {
	rr := newTrueNASAppRegistryFixture()

	resource := ResolveResourceContext(rr, "Nextcloud").Resource
	if resource == nil {
		t.Fatal("expected resolved resource for TrueNAS app")
	}
	if resource.Type != ResourceTypeAppContainer {
		t.Fatalf("expected app-container resource, got %q", resource.Type)
	}
	if resource.TrueNAS == nil {
		t.Fatalf("expected TrueNAS metadata on resolved resource, got %+v", resource)
	}
	if resource.Name != "Nextcloud" {
		t.Fatalf("expected canonical app name Nextcloud, got %q", resource.Name)
	}
}

func newTrueNASAppRegistryFixture() *ResourceRegistry {
	rr := NewRegistry(nil)
	now := time.Now().UTC()
	hostID := "agent:truenas-main"
	hostSourceID := "truenas-system:truenas-main"
	rr.IngestRecords(SourceTrueNAS, []IngestRecord{
		{
			SourceID: hostSourceID,
			Resource: Resource{
				ID:        hostID,
				Type:      ResourceTypeAgent,
				Name:      "truenas-main",
				Status:    StatusOnline,
				LastSeen:  now,
				UpdatedAt: now,
				Agent: &AgentData{
					Hostname: "truenas-main",
					Platform: "truenas",
				},
				TrueNAS: &TrueNASData{Hostname: "truenas-main"},
			},
			Identity: ResourceIdentity{Hostnames: []string{"truenas-main"}},
		},
		{
			SourceID:       "app:nextcloud",
			ParentSourceID: hostSourceID,
			Resource: Resource{
				ID:         "app-container:truenas-main:nextcloud",
				Type:       ResourceTypeAppContainer,
				Name:       "Nextcloud",
				Status:     StatusOnline,
				LastSeen:   now,
				UpdatedAt:  now,
				ParentID:   stringPtr(hostID),
				ParentName: "truenas-main",
				Docker: &DockerData{
					ContainerID: "nextcloud",
					Hostname:    "truenas-main",
				},
				TrueNAS: &TrueNASData{Hostname: "truenas-main"},
				Canonical: &CanonicalIdentity{
					DisplayName: "Nextcloud",
					Hostname:    "truenas-main",
					PrimaryID:   "nextcloud",
					Aliases:     []string{"Nextcloud", "nextcloud"},
				},
				Tags: []string{"truenas", "app"},
			},
			Identity: ResourceIdentity{Hostnames: []string{"truenas-main"}},
		},
	})
	return rr
}

func stringPtr(value string) *string {
	return &value
}

func TestResolveResource_Host(t *testing.T) {
	rr := NewRegistry(nil)
	rr.IngestSnapshot(models.StateSnapshot{
		Hosts: []models.Host{{ID: "host1", Hostname: "myserver", Platform: "linux"}},
	})
	loc := ResolveResource(rr, "myserver")
	if !loc.Found || loc.ResourceType != "agent" {
		t.Fatalf("expected agent, got found=%v type=%q", loc.Found, loc.ResourceType)
	}
	if loc.Platform != "linux" {
		t.Fatalf("expected linux platform, got %q", loc.Platform)
	}
	if loc.TargetID != "host1" {
		t.Fatalf("expected TargetID=host1 (canonical target ID), got %q", loc.TargetID)
	}

	// Lookup by agent/source ID should also work.
	loc2 := ResolveResource(rr, "host1")
	if !loc2.Found || loc2.ResourceType != "agent" {
		t.Fatalf("expected agent lookup by agent ID, got found=%v type=%q", loc2.Found, loc2.ResourceType)
	}
}

func TestResolveResource_K8sCluster(t *testing.T) {
	rr := NewRegistry(nil)
	rr.IngestSnapshot(models.StateSnapshot{
		KubernetesClusters: []models.KubernetesCluster{{
			ID:      "k8s1",
			Name:    "prod",
			AgentID: "agent-1",
		}},
	})
	loc := ResolveResource(rr, "prod")
	if !loc.Found || loc.ResourceType != "k8s-cluster" {
		t.Fatalf("expected k8s-cluster, got found=%v type=%q", loc.Found, loc.ResourceType)
	}
	if loc.K8sAgentID != "agent-1" {
		t.Fatalf("expected agent-1, got %q", loc.K8sAgentID)
	}
}

func TestResolveResource_K8sPod(t *testing.T) {
	rr := NewRegistry(nil)
	rr.IngestSnapshot(models.StateSnapshot{
		KubernetesClusters: []models.KubernetesCluster{{
			ID:      "k8s1",
			Name:    "prod",
			AgentID: "agent-1",
			Pods: []models.KubernetesPod{{
				Name:      "nginx-abc",
				Namespace: "default",
			}},
		}},
	})
	loc := ResolveResource(rr, "nginx-abc")
	if !loc.Found || loc.ResourceType != "k8s-pod" {
		t.Fatalf("expected k8s-pod, got found=%v type=%q", loc.Found, loc.ResourceType)
	}
	if loc.K8sNamespace != "default" {
		t.Fatalf("expected namespace default, got %q", loc.K8sNamespace)
	}
	if loc.K8sClusterName != "prod" {
		t.Fatalf("expected cluster prod, got %q", loc.K8sClusterName)
	}
}

func TestResolveResource_K8sDeployment(t *testing.T) {
	rr := NewRegistry(nil)
	rr.IngestSnapshot(models.StateSnapshot{
		KubernetesClusters: []models.KubernetesCluster{{
			ID:      "k8s1",
			Name:    "prod",
			AgentID: "agent-1",
			Deployments: []models.KubernetesDeployment{{
				Name:      "web-deploy",
				Namespace: "production",
			}},
		}},
	})
	loc := ResolveResource(rr, "web-deploy")
	if !loc.Found || loc.ResourceType != "k8s-deployment" {
		t.Fatalf("expected k8s-deployment, got found=%v type=%q", loc.Found, loc.ResourceType)
	}
	if loc.K8sNamespace != "production" {
		t.Fatalf("expected namespace production, got %q", loc.K8sNamespace)
	}
}

func TestResolveResource_NotFound(t *testing.T) {
	rr := NewRegistry(nil)
	rr.IngestSnapshot(models.StateSnapshot{})
	loc := ResolveResource(rr, "nonexistent")
	if loc.Found {
		t.Fatal("expected not found")
	}
	if loc.Name != "nonexistent" {
		t.Fatalf("expected name preserved, got %q", loc.Name)
	}
}

func TestResolveResourceContext_ReturnsGovernedResource(t *testing.T) {
	rr := NewRegistry(nil)
	rr.IngestSnapshot(models.StateSnapshot{
		Containers: []models.Container{{
			ID:   "lxc-1",
			Name: "customer-pg",
			VMID: 201,
			Node: "node1",
			Type: "lxc",
			Tags: []string{"customer-data"},
		}},
	})

	resolved := ResolveResourceContext(rr, "customer-pg")
	if !resolved.Location.Found || resolved.Location.ResourceType != "system-container" {
		t.Fatalf("expected resolved system container, got %#v", resolved.Location)
	}
	if resolved.Resource == nil {
		t.Fatal("expected unified resource metadata")
	}
	if resolved.Resource.Policy == nil {
		t.Fatal("expected policy metadata on resolved resource")
	}
	if resolved.Resource.Policy.Sensitivity != ResourceSensitivityRestricted {
		t.Fatalf("expected restricted sensitivity, got %q", resolved.Resource.Policy.Sensitivity)
	}
	if resolved.Resource.Policy.Routing.Scope != ResourceRoutingScopeLocalOnly {
		t.Fatalf("expected local-only routing, got %q", resolved.Resource.Policy.Routing.Scope)
	}
	if resolved.Resource.AISafeSummary == "" {
		t.Fatal("expected aiSafeSummary to be populated")
	}
	if resolved.Resource.AISafeSummary == resolved.Resource.Name {
		t.Fatalf("expected aiSafeSummary to avoid raw name, got %q", resolved.Resource.AISafeSummary)
	}
}

func TestResolveResourceContext_NotFound(t *testing.T) {
	rr := NewRegistry(nil)
	rr.IngestSnapshot(models.StateSnapshot{})

	resolved := ResolveResourceContext(rr, "missing")
	if resolved.Location.Found {
		t.Fatalf("expected missing lookup to remain not found, got %#v", resolved.Location)
	}
	if resolved.Resource != nil {
		t.Fatalf("expected no resolved resource for missing lookup, got %#v", resolved.Resource)
	}
}

// linkedGuestEstate is an agent inside a vSphere VM, joined by an operator
// link, as Pulse sees it after a restart before the agent reports again: the
// published registry has only the VM, and saved-host continuity fills in the
// agent.
type linkedGuestEstate struct {
	saved     models.Host
	vmRecords []IngestRecord
	agentID   string
	vmID      string
}

func newLinkedGuestEstate(t *testing.T) linkedGuestEstate {
	t.Helper()
	now := time.Now().UTC()
	estate := linkedGuestEstate{
		saved: models.Host{
			ID: "host-app-guest", MachineID: "machine-app-guest", Hostname: "app-guest",
			Platform: "linux", Status: "offline", LastSeen: now.Add(-10 * time.Minute),
			Memory: models.Memory{Total: 8 << 30, Used: 7 << 30, Free: 1 << 30, Usage: 88},
		},
		vmRecords: []IngestRecord{{
			SourceID: "vc-1:vm:vm-42",
			Resource: Resource{
				Type:       ResourceTypeVM,
				Technology: "vmware",
				Name:       "app-guest",
				Status:     StatusOnline,
				LastSeen:   now,
				Metrics:    &ResourceMetrics{Memory: &MetricValue{Percent: 40, Source: SourceVMware}},
				VMware:     &VMwareData{ConnectionID: "vc-1", ManagedObjectID: "vm-42", EntityType: "vm"},
			},
			Identity: ResourceIdentity{Hostnames: []string{"app-guest"}},
		}},
	}
	unlinked := NewMonitorAdapter(NewRegistry(nil))
	unlinked.PopulateSnapshotAndSupplemental(
		models.StateSnapshot{Hosts: []models.Host{estate.saved}, LastUpdate: now},
		map[DataSource][]IngestRecord{SourceVMware: estate.vmRecords},
	)
	if len(unlinked.VMs()) != 1 || len(unlinked.Hosts()) != 1 {
		t.Fatalf("unlinked estate = %d VMs, %d agents, want one of each", len(unlinked.VMs()), len(unlinked.Hosts()))
	}
	estate.vmID, estate.agentID = unlinked.VMs()[0].ID(), unlinked.Hosts()[0].ID()
	return estate
}

// readStateAfterRestart publishes the VM alone and overlays the saved agent,
// as Monitor.GetUnifiedReadStateOrSnapshot does.
func (e linkedGuestEstate) readStateAfterRestart(store ResourceStore) *MonitorAdapter {
	published := NewMonitorAdapter(NewRegistry(store))
	published.PopulateSnapshotAndSupplemental(
		models.StateSnapshot{LastUpdate: time.Now().UTC()},
		map[DataSource][]IngestRecord{SourceVMware: e.vmRecords},
	)
	return ReadStateWithHostContinuity(published, []IngestRecord{HostIngestRecord(e.saved)}).(*MonitorAdapter)
}

// An operator link names one identity, so every reference to the saved
// agent resolves to the VM, as it does once the agent reports and folds in.
// The agent's saved telemetry stays on its own row in the read state and in
// the resources API, which seeds a registry from that listing and re-applies
// the links.
func TestContinuityAgentLinkedIntoLiveGuestAnswersToTheGuest(t *testing.T) {
	estate := newLinkedGuestEstate(t)
	store := NewMemoryStore()
	if err := store.AddLink(ResourceLink{ResourceA: estate.vmID, ResourceB: estate.agentID, PrimaryID: estate.agentID}); err != nil {
		t.Fatalf("add link: %v", err)
	}
	readState := estate.readStateAfterRestart(store)
	resources := NewRegistry(store)
	resources.IngestResources(readState.GetAll())

	for _, registry := range []struct {
		name     string
		registry *ResourceRegistry
	}{
		{"read state", readState.registry},
		{"resources API", resources},
	} {
		t.Run(registry.name, func(t *testing.T) {
			rr := registry.registry
			agent, ok := rr.Get(estate.agentID)
			if !ok || agent.Status != StatusOffline {
				t.Fatalf("saved agent row = %+v (listed=%v), want its own offline row", agent, ok)
			}
			vm, ok := rr.Get(estate.vmID)
			if !ok {
				t.Fatalf("linked VM %s missing", estate.vmID)
			}
			if vm.Agent != nil || vm.Status != StatusOnline || vm.Metrics == nil || vm.Metrics.Memory == nil || vm.Metrics.Memory.Source != SourceVMware {
				t.Fatalf("VM agent=%v status=%s metrics=%+v, want vSphere's online VM without the saved agent's payload", vm.Agent != nil, vm.Status, vm.Metrics)
			}
			// The hostname both rows carry stays unambiguous: the saved row shares
			// the VM's identity.
			for _, ref := range []string{estate.agentID, "agent:" + estate.saved.ID, estate.saved.MachineID, "app-guest"} {
				if resolved, ok := rr.ResolveReferenceID(ref); !ok || resolved != estate.vmID {
					t.Fatalf("ResolveReferenceID(%q) = %q (%v), want the link primary %s", ref, resolved, ok, estate.vmID)
				}
				if _, resolved, ok := rr.GetByReference(ref); !ok || resolved != estate.vmID {
					t.Fatalf("GetByReference(%q) = %q (%v), want the link primary %s", ref, resolved, ok, estate.vmID)
				}
			}
			if resolved, ok := rr.ResolveReferenceID(estate.vmID); !ok || resolved != estate.vmID {
				t.Fatalf("VM reference resolved to %q (%v)", resolved, ok)
			}
		})
	}
	if resolved, ok := readState.ResolveCanonicalResourceID("agent:" + estate.saved.ID); !ok || resolved != estate.vmID {
		t.Fatalf("read-state canonical resolution = %q (%v), want %s", resolved, ok, estate.vmID)
	}

	// Once the agent reports, the link folds it in as before.
	live := estate.saved
	live.Status, live.LastSeen = "online", time.Now().UTC()
	published := NewMonitorAdapter(NewRegistry(store))
	published.PopulateSnapshotAndSupplemental(
		models.StateSnapshot{Hosts: []models.Host{live}, LastUpdate: time.Now().UTC()},
		map[DataSource][]IngestRecord{SourceVMware: estate.vmRecords},
	)
	if len(published.Hosts()) != 0 {
		t.Fatal("reporting agent still listed beside its linked VM")
	}
	if resolved, ok := published.ResolveCanonicalResourceID(estate.agentID); !ok || resolved != estate.vmID {
		t.Fatalf("folded agent resolved to %q (%v), want %s", resolved, ok, estate.vmID)
	}
}

// A saved primary never captures a live member: the live row keeps its own
// references and telemetry, and the saved row its own, until the primary
// reports and the link folds them.
func TestContinuityPrimaryLeavesLiveLinkMemberItsOwnIdentity(t *testing.T) {
	now := time.Now().UTC()
	live := models.Host{ID: "host-live", MachineID: "machine-live", Hostname: "live", Platform: "linux", Status: "online", LastSeen: now, CPUUsage: 23}
	saved := models.Host{ID: "host-saved", MachineID: "machine-saved", Hostname: "saved", Platform: "linux", Status: "offline", LastSeen: now.Add(-time.Hour)}

	ids := NewMonitorAdapter(NewRegistry(nil))
	ids.PopulateFromSnapshot(models.StateSnapshot{Hosts: []models.Host{live, saved}, LastUpdate: now})
	if len(ids.Hosts()) != 2 {
		t.Fatalf("unlinked estate has %d agents, want 2", len(ids.Hosts()))
	}
	agentIDs := map[string]string{}
	for _, host := range ids.Hosts() {
		agentIDs[host.AgentID()] = host.ID()
	}
	liveID, savedID := agentIDs[live.ID], agentIDs[saved.ID]

	store := NewMemoryStore()
	if err := store.AddLink(ResourceLink{ResourceA: savedID, ResourceB: liveID, PrimaryID: savedID}); err != nil {
		t.Fatalf("add link: %v", err)
	}
	published := NewMonitorAdapter(NewRegistry(store))
	published.PopulateFromSnapshot(models.StateSnapshot{Hosts: []models.Host{live}, LastUpdate: now})
	readState := ReadStateWithHostContinuity(published, []IngestRecord{HostIngestRecord(saved)}).(*MonitorAdapter)
	resources := NewRegistry(store)
	resources.IngestResources(readState.GetAll())

	for name, rr := range map[string]*ResourceRegistry{"read state": readState.registry, "resources API": resources} {
		liveRow, ok := rr.Get(liveID)
		if !ok || liveRow.Status != StatusOnline || len(liveRow.Sources) != 1 {
			t.Fatalf("%s: live member = %+v (listed=%v), want its own online row", name, liveRow, ok)
		}
		if _, ok := rr.Get(savedID); !ok {
			t.Fatalf("%s: saved primary row missing", name)
		}
		for ref, want := range map[string]string{liveID: liveID, "agent:" + live.ID: liveID, savedID: savedID, "agent:" + saved.ID: savedID} {
			if resolved, ok := rr.ResolveReferenceID(ref); !ok || resolved != want {
				t.Fatalf("%s: %q resolved to %q (%v), want %s", name, ref, resolved, ok, want)
			}
		}
	}
}

// An observation that merges into a saved row makes it a live row again, so
// the link folds it: the resources API's record replay is one such path.
func TestObservationMergedIntoASavedRowLetsItsLinkFold(t *testing.T) {
	estate := newLinkedGuestEstate(t)
	store := NewMemoryStore()
	if err := store.AddLink(ResourceLink{ResourceA: estate.vmID, ResourceB: estate.agentID, PrimaryID: estate.vmID}); err != nil {
		t.Fatalf("add link: %v", err)
	}
	rr := estate.readStateAfterRestart(store).registry
	if _, held := rr.Get(estate.agentID); !held {
		t.Fatal("saved agent not listed before it reports")
	}
	live := estate.saved
	live.Status, live.LastSeen = "online", time.Now().UTC()
	rr.IngestRecords(SourceAgent, []IngestRecord{HostIngestRecord(live)})
	if _, listed := rr.Get(estate.agentID); listed {
		t.Fatal("reported agent still listed beside its linked VM")
	}
	if vm, ok := rr.Get(estate.vmID); !ok || vm.Agent == nil {
		t.Fatalf("linked VM = %+v (listed=%v), want it carrying the reported agent", vm, ok)
	}
}

// Holds follow the links one pass applies, whatever their order: a primary a
// later link folds away hands its held members to the row holding it, a saved
// member held under a saved primary answers to that primary's own target, and
// a cycle of saved members resolves each to itself.
func TestLinkHoldsFollowTheirPrimaryThroughThePass(t *testing.T) {
	saved := func(id string) Resource {
		return Resource{ID: id, Type: ResourceTypeAgent, Name: id, Status: StatusOffline, Sources: []DataSource{SourceAgent}, continuityOnly: true}
	}
	vm := func(id string) Resource {
		return Resource{ID: id, Type: ResourceTypeVM, Name: id, Status: StatusOnline, Sources: []DataSource{SourceVMware}}
	}
	for _, tc := range []struct {
		name      string
		resources []Resource
		links     []ResourceLink
		want      map[string]string
	}{
		{
			name:      "primary folded later",
			resources: []Resource{saved("agent-a"), vm("vm-v"), vm("vm-w")},
			links: []ResourceLink{
				{ResourceA: "agent-a", ResourceB: "vm-v", PrimaryID: "vm-v"},
				{ResourceA: "vm-v", ResourceB: "vm-w", PrimaryID: "vm-w"},
			},
			want: map[string]string{"agent-a": "vm-w", "vm-v": "vm-w", "vm-w": "vm-w"},
		},
		{
			name:      "saved primary held in turn",
			resources: []Resource{saved("agent-x"), saved("agent-a"), vm("vm-v")},
			links: []ResourceLink{
				{ResourceA: "agent-x", ResourceB: "agent-a", PrimaryID: "agent-a"},
				{ResourceA: "agent-a", ResourceB: "vm-v", PrimaryID: "vm-v"},
			},
			want: map[string]string{"agent-x": "vm-v", "agent-a": "vm-v", "vm-v": "vm-v"},
		},
		{
			name:      "cycle",
			resources: []Resource{saved("agent-a"), saved("agent-b"), saved("agent-c")},
			links: []ResourceLink{
				{ResourceA: "agent-a", ResourceB: "agent-b", PrimaryID: "agent-a"},
				{ResourceA: "agent-b", ResourceB: "agent-c", PrimaryID: "agent-b"},
				{ResourceA: "agent-c", ResourceB: "agent-a", PrimaryID: "agent-c"},
			},
			want: map[string]string{"agent-a": "agent-a", "agent-b": "agent-b", "agent-c": "agent-c"},
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			store := NewMemoryStore()
			for _, link := range tc.links {
				if err := store.AddLink(link); err != nil {
					t.Fatalf("add link: %v", err)
				}
			}
			rr := NewRegistry(store)
			rr.IngestResources(tc.resources)
			for ref, want := range tc.want {
				if resolved, ok := rr.ResolveReferenceID(ref); !ok || resolved != want {
					t.Fatalf("%q resolved to %q (%v), want %s", ref, resolved, ok, want)
				}
			}
			for _, resource := range tc.resources {
				if !resource.continuityOnly {
					continue
				}
				if row, listed := rr.Get(resource.ID); !listed || row.Status != StatusOffline {
					t.Fatalf("saved row %s = %+v (listed=%v), want it kept", resource.ID, row, listed)
				}
			}
		})
	}
}

// A saved agent answers to the row its link partner folds into, in every
// link order: the read-state overlay and the resources API, which seeds a
// registry from that listing and re-applies the links, hold it alike. The partner here is the vSphere VM the agent was linked into from
// its own page, and the VM is itself linked into a TrueNAS pool, so the
// published registry folds the VM away before continuity adds the agent;
// the hold used to need both members listed and left the agent answering for
// itself. When two links would fold the agent, the chain precedence picks:
// the guest outranks the pool, whichever link the store lists first.
func TestSavedLinkMemberHoldsFollowTheChainInAnyLinkOrder(t *testing.T) {
	estate := newLinkedGuestEstate(t)
	now := time.Now().UTC()
	pool := func(name string) IngestRecord {
		return IngestRecord{
			SourceID: "system:tn-1:pool:" + name,
			Resource: Resource{
				Type: ResourceTypeStorage, Name: name, Status: StatusOnline, LastSeen: now,
				Storage: &StorageMeta{Type: "zfs-pool", Platform: "truenas", Topology: "pool"},
			},
		}
	}
	records := map[DataSource][]IngestRecord{SourceVMware: estate.vmRecords, SourceTrueNAS: {pool("tank"), pool("vault")}}
	probe := NewMonitorAdapter(NewRegistry(nil))
	probe.PopulateSnapshotAndSupplemental(models.StateSnapshot{LastUpdate: now}, records)
	poolIDs := map[string]string{}
	for _, resource := range probe.GetAll() {
		if resource.Type == ResourceTypeStorage {
			poolIDs[resource.Name] = resource.ID
		}
	}
	if len(poolIDs) != 2 {
		t.Fatalf("probe estate = %+v, want two pools", probe.GetAll())
	}
	created := time.Date(2026, 10, 1, 9, 0, 0, 0, time.UTC)

	for _, tc := range []struct {
		name  string
		links []ResourceLink
		want  string
	}{
		{
			name: "partner folded into a third resource",
			links: []ResourceLink{
				{ResourceA: estate.agentID, ResourceB: estate.vmID, PrimaryID: estate.agentID, CreatedAt: created},
				{ResourceA: estate.vmID, ResourceB: poolIDs["tank"], PrimaryID: poolIDs["tank"], CreatedAt: created.Add(time.Minute)},
			},
			want: poolIDs["tank"],
		},
		{
			name: "competing links pick the guest",
			links: []ResourceLink{
				{ResourceA: estate.agentID, ResourceB: poolIDs["vault"], PrimaryID: poolIDs["vault"], CreatedAt: created},
				{ResourceA: estate.agentID, ResourceB: estate.vmID, PrimaryID: estate.agentID, CreatedAt: created.Add(time.Minute)},
			},
			want: estate.vmID,
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			for _, order := range linkOrders(len(tc.links)) {
				store := NewMemoryStore()
				for _, i := range order {
					if err := store.AddLink(tc.links[i]); err != nil {
						t.Fatalf("add link: %v", err)
					}
				}
				published := NewMonitorAdapter(NewRegistry(store))
				published.PopulateSnapshotAndSupplemental(models.StateSnapshot{LastUpdate: time.Now().UTC()}, records)
				readState := ReadStateWithHostContinuity(published, []IngestRecord{HostIngestRecord(estate.saved)}).(*MonitorAdapter)
				resources := NewRegistry(store)
				resources.IngestResources(readState.GetAll())
				for _, view := range []struct {
					name string
					rr   *ResourceRegistry
				}{{"read state", readState.registry}, {"resources API", resources}} {
					if agent, ok := view.rr.Get(estate.agentID); !ok || agent.Status != StatusOffline {
						t.Fatalf("order %v, %s: saved agent row = %+v (listed=%v), want its own offline row", order, view.name, agent, ok)
					}
					if target, ok := view.rr.Get(tc.want); !ok || target.Agent != nil {
						t.Fatalf("order %v, %s: hold target %s = %+v (listed=%v), want it listed without the saved agent's payload", order, view.name, tc.want, target, ok)
					}
					for _, ref := range []string{estate.agentID, "agent:" + estate.saved.ID} {
						if got, ok := view.rr.ResolveReferenceID(ref); !ok || got != tc.want {
							t.Fatalf("order %v, %s: ResolveReferenceID(%q) = %q (%v), want %s", order, view.name, ref, got, ok, tc.want)
						}
						if _, got, ok := view.rr.GetByReference(ref); !ok || got != tc.want {
							t.Fatalf("order %v, %s: GetByReference(%q) = %q (%v), want %s", order, view.name, ref, got, ok, tc.want)
						}
					}
				}
			}
		})
	}
}

// A saved member held under a partner answers to the row that partner
// survives in. A seeded listing can carry the partner inside a storage row
// that the changed links now fold into a guest, so the hold ranks the guest,
// not the row that left the registry, and repeating the pass changes nothing.
func TestSavedLinkMemberHoldFollowsThePartnersSurvivingRow(t *testing.T) {
	estate := newChainLinkEstate(t)
	created := time.Date(2026, 10, 1, 9, 0, 0, 0, time.UTC)
	vm, pool, otherPool, guest := estate.ids["pve-vm"], estate.ids["tank"], estate.ids["vault"], estate.ids["vsphere-vm"]

	probe := NewMonitorAdapter(NewRegistry(nil))
	probe.PopulateSnapshotAndSupplemental(estate.snapshot, estate.records)
	var savedID string
	for _, resource := range ReadStateWithHostContinuity(probe, []IngestRecord{HostIngestRecord(estate.saved)}).(*MonitorAdapter).GetAll() {
		if resource.Agent != nil && resource.Agent.AgentID == estate.saved.ID {
			savedID = resource.ID
		}
	}
	if savedID == "" {
		t.Fatal("overlay did not list the saved host")
	}

	savedLinks := []ResourceLink{
		{ResourceA: savedID, ResourceB: otherPool, PrimaryID: otherPool, CreatedAt: created},
		{ResourceA: savedID, ResourceB: vm, PrimaryID: vm, CreatedAt: created.Add(time.Minute)},
	}
	published := NewMemoryStore()
	for _, link := range append([]ResourceLink{{ResourceA: vm, ResourceB: pool, PrimaryID: pool, CreatedAt: created}}, savedLinks...) {
		if err := published.AddLink(link); err != nil {
			t.Fatalf("add link: %v", err)
		}
	}
	adapter := NewMonitorAdapter(NewRegistry(published))
	adapter.PopulateSnapshotAndSupplemental(estate.snapshot, estate.records)
	readState := ReadStateWithHostContinuity(adapter, []IngestRecord{HostIngestRecord(estate.saved)}).(*MonitorAdapter)

	// The links change after the listing was published: the pool now folds
	// into the vSphere VM, which takes the Proxmox VM the pool held with it.
	changed := NewMemoryStore()
	for _, link := range append([]ResourceLink{{ResourceA: pool, ResourceB: guest, PrimaryID: guest, CreatedAt: created.Add(2 * time.Minute)}}, savedLinks...) {
		if err := changed.AddLink(link); err != nil {
			t.Fatalf("add link: %v", err)
		}
	}
	seeded := NewRegistry(changed)
	seeded.IngestResources(readState.GetAll())
	check := func(step string) {
		t.Helper()
		if got, ok := seeded.ResolveReferenceID(savedID); !ok || got != guest {
			t.Fatalf("%s: saved agent resolved to %q (%v), want the guest %s its partner folded into", step, got, ok, guest)
		}
		if _, listed := seeded.Get(pool); listed {
			t.Fatalf("%s: pool still listed beside the guest", step)
		}
	}
	check("seeded")
	seeded.mu.Lock()
	seeded.applyManualLinks(nil)
	seeded.mu.Unlock()
	check("second pass")
}