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.

24.1 KB
Raw Blame
package config

import (
	"encoding/json"
	"os"
	"path/filepath"
	"sync"
	"testing"
	"time"
)

func TestGuestMetadataStore_Get(t *testing.T) {
	tmpDir := t.TempDir()
	store := NewGuestMetadataStore(tmpDir, nil)

	// Test get on empty store
	result := store.Get("nonexistent")
	if result != nil {
		t.Error("Get on empty store should return nil")
	}

	// Add metadata
	store.metadata["pve1:node1:100"] = &GuestMetadata{
		ID:            "pve1:node1:100",
		CustomURL:     "http://example.com",
		Description:   "Test VM",
		Tags:          []string{"tag1", "tag2"},
		LastKnownName: "test-vm",
		LastKnownType: "qemu",
	}

	// Test get existing
	result = store.Get("pve1:node1:100")
	if result == nil {
		t.Fatal("Get should return metadata for existing entry")
	}
	if result.CustomURL != "http://example.com" {
		t.Errorf("CustomURL = %q, want %q", result.CustomURL, "http://example.com")
	}
	if result.Description != "Test VM" {
		t.Errorf("Description = %q, want %q", result.Description, "Test VM")
	}
	if len(result.Tags) != 2 {
		t.Errorf("Tags count = %d, want 2", len(result.Tags))
	}
	if result.LastKnownName != "test-vm" {
		t.Errorf("LastKnownName = %q, want %q", result.LastKnownName, "test-vm")
	}
	if result.LastKnownType != "qemu" {
		t.Errorf("LastKnownType = %q, want %q", result.LastKnownType, "qemu")
	}

	result.CustomURL = "http://mutated.example.com"
	result.Tags[0] = "mutated"
	again := store.Get("pve1:node1:100")
	if again.CustomURL != "http://example.com" {
		t.Errorf("Get should return a metadata copy; stored CustomURL = %q, want %q", again.CustomURL, "http://example.com")
	}
	if again.Tags[0] != "tag1" {
		t.Errorf("Get should copy slice fields; stored tag = %q, want tag1", again.Tags[0])
	}
}

func TestGuestMetadataStore_GetAll(t *testing.T) {
	tmpDir := t.TempDir()
	store := NewGuestMetadataStore(tmpDir, nil)

	// Test empty store
	all := store.GetAll()
	if len(all) != 0 {
		t.Errorf("GetAll on empty store returned %d entries, want 0", len(all))
	}

	// Add metadata
	store.metadata["id1"] = &GuestMetadata{ID: "id1", CustomURL: "url1"}
	store.metadata["id2"] = &GuestMetadata{ID: "id2", CustomURL: "url2"}

	// Test GetAll returns all entries
	all = store.GetAll()
	if len(all) != 2 {
		t.Errorf("GetAll returned %d entries, want 2", len(all))
	}

	// Verify it's a copy (modification shouldn't affect store)
	all["id3"] = &GuestMetadata{ID: "id3"}
	if len(store.metadata) != 2 {
		t.Error("GetAll should return a copy, not the original map")
	}
	all["id1"].CustomURL = "mutated"
	if got := store.Get("id1").CustomURL; got != "url1" {
		t.Errorf("GetAll should return metadata copies; stored CustomURL = %q, want url1", got)
	}
}

func TestGuestMetadataStore_Set(t *testing.T) {
	tmpDir := t.TempDir()
	store := NewGuestMetadataStore(tmpDir, nil)

	// Test set nil
	err := store.Set("id1", nil)
	if err == nil {
		t.Error("Set with nil metadata should return error")
	}

	// Test successful set
	meta := &GuestMetadata{
		CustomURL:     "http://test.com",
		Description:   "Test desc",
		Tags:          []string{"tag1"},
		LastKnownName: "vm1",
		LastKnownType: "lxc",
	}
	err = store.Set("id1", meta)
	if err != nil {
		t.Fatalf("Set failed: %v", err)
	}

	// Verify Set does not mutate caller-owned metadata.
	if meta.ID != "" {
		t.Errorf("caller metadata ID = %q, want empty", meta.ID)
	}

	// Verify stored
	stored := store.Get("id1")
	if stored == nil {
		t.Fatal("Set did not store metadata")
	}
	if stored.CustomURL != "http://test.com" {
		t.Errorf("Stored CustomURL = %q, want %q", stored.CustomURL, "http://test.com")
	}
	if stored.LastKnownName != "vm1" {
		t.Errorf("Stored LastKnownName = %q, want %q", stored.LastKnownName, "vm1")
	}
	if stored.ID != "id1" {
		t.Errorf("Stored ID = %q, want %q", stored.ID, "id1")
	}

	meta.CustomURL = "http://mutated.example"
	meta.Tags[0] = "mutated"
	stored = store.Get("id1")
	if stored.CustomURL != "http://test.com" {
		t.Errorf("Set should store a metadata copy; stored CustomURL = %q, want %q", stored.CustomURL, "http://test.com")
	}
	if stored.Tags[0] != "tag1" {
		t.Errorf("Set should copy slice fields; stored tag = %q, want tag1", stored.Tags[0])
	}

	// Verify persisted to disk
	filePath := filepath.Join(tmpDir, "guest_metadata.json")
	data, err := os.ReadFile(filePath)
	if err != nil {
		t.Fatalf("Failed to read persisted file: %v", err)
	}

	var fileData map[string]*GuestMetadata
	if err := json.Unmarshal(data, &fileData); err != nil {
		t.Fatalf("Failed to unmarshal persisted data: %v", err)
	}
	if fileData["id1"] == nil {
		t.Error("Metadata not persisted")
	}
}

func TestGuestMetadataStore_Set_UpdateExisting(t *testing.T) {
	tmpDir := t.TempDir()
	store := NewGuestMetadataStore(tmpDir, nil)

	// Set initial
	err := store.Set("id1", &GuestMetadata{CustomURL: "url1", Description: "desc1"})
	if err != nil {
		t.Fatalf("Initial Set failed: %v", err)
	}

	// Update
	err = store.Set("id1", &GuestMetadata{CustomURL: "url2", Description: "desc2"})
	if err != nil {
		t.Fatalf("Update Set failed: %v", err)
	}

	// Verify updated
	meta := store.Get("id1")
	if meta.CustomURL != "url2" {
		t.Errorf("CustomURL = %q, want %q", meta.CustomURL, "url2")
	}
	if meta.Description != "desc2" {
		t.Errorf("Description = %q, want %q", meta.Description, "desc2")
	}
}

func TestGuestMetadataStore_Delete(t *testing.T) {
	tmpDir := t.TempDir()
	store := NewGuestMetadataStore(tmpDir, nil)

	// Add metadata
	store.metadata["id1"] = &GuestMetadata{ID: "id1", CustomURL: "url1"}

	// Delete
	err := store.Delete("id1")
	if err != nil {
		t.Fatalf("Delete failed: %v", err)
	}

	// Verify deleted
	if store.Get("id1") != nil {
		t.Error("Delete did not remove metadata")
	}

	// Delete nonexistent (should not error)
	err = store.Delete("nonexistent")
	if err != nil {
		t.Errorf("Delete nonexistent should not error: %v", err)
	}
}

func TestGuestMetadataStore_ReplaceAll(t *testing.T) {
	tmpDir := t.TempDir()
	store := NewGuestMetadataStore(tmpDir, nil)

	// Add initial data
	store.metadata["old1"] = &GuestMetadata{ID: "old1"}

	// Replace all
	newData := map[string]*GuestMetadata{
		"new1": {CustomURL: "url1", Tags: []string{"t1"}},
		"new2": {CustomURL: "url2"},
	}

	err := store.ReplaceAll(newData)
	if err != nil {
		t.Fatalf("ReplaceAll failed: %v", err)
	}

	// Verify old data gone
	if store.Get("old1") != nil {
		t.Error("ReplaceAll should remove old entries")
	}

	// Verify new data present
	if store.Get("new1") == nil || store.Get("new2") == nil {
		t.Error("ReplaceAll should add new entries")
	}

	// Verify IDs set correctly
	if store.Get("new1").ID != "new1" {
		t.Errorf("ID = %q, want %q", store.Get("new1").ID, "new1")
	}

	// Verify nil tags converted to empty slice
	if store.Get("new2").Tags == nil {
		t.Error("ReplaceAll should convert nil tags to empty slice")
	}
}

func TestGuestMetadataStore_ReplaceAll_NilEntry(t *testing.T) {
	tmpDir := t.TempDir()
	store := NewGuestMetadataStore(tmpDir, nil)

	// Replace with map containing nil entry
	newData := map[string]*GuestMetadata{
		"valid": {CustomURL: "url1"},
		"nil":   nil,
	}

	err := store.ReplaceAll(newData)
	if err != nil {
		t.Fatalf("ReplaceAll failed: %v", err)
	}

	// Verify valid entry present
	if store.Get("valid") == nil {
		t.Error("ReplaceAll should add valid entries")
	}

	// Verify nil entry skipped
	if store.Get("nil") != nil {
		t.Error("ReplaceAll should skip nil entries")
	}
}

func TestGuestMetadataStore_Load(t *testing.T) {
	tmpDir := t.TempDir()

	// Write test file
	fileData := map[string]*GuestMetadata{
		"pve1:node1:100": {
			ID:            "pve1:node1:100",
			CustomURL:     "http://vm1.local",
			Description:   "Production VM",
			Tags:          []string{"prod", "web"},
			LastKnownName: "web-server",
			LastKnownType: "qemu",
		},
		"pve1:node1:101": {
			ID:          "pve1:node1:101",
			CustomURL:   "http://ct1.local",
			Description: "Dev container",
		},
	}
	data, _ := json.Marshal(fileData)
	filePath := filepath.Join(tmpDir, "guest_metadata.json")
	if err := os.WriteFile(filePath, data, 0644); err != nil {
		t.Fatalf("Failed to write test file: %v", err)
	}

	// Load
	store := NewGuestMetadataStore(tmpDir, nil)
	err := store.Load()
	if err != nil {
		t.Fatalf("Load failed: %v", err)
	}

	// Verify loaded
	if len(store.metadata) != 2 {
		t.Errorf("Metadata count = %d, want 2", len(store.metadata))
	}

	meta := store.Get("pve1:node1:100")
	if meta == nil {
		t.Fatal("Load did not load metadata")
	}
	if meta.CustomURL != "http://vm1.local" {
		t.Errorf("CustomURL = %q, want %q", meta.CustomURL, "http://vm1.local")
	}
	if meta.LastKnownName != "web-server" {
		t.Errorf("LastKnownName = %q, want %q", meta.LastKnownName, "web-server")
	}
}

func TestGuestMetadataStore_Load_NonExistent(t *testing.T) {
	tmpDir := t.TempDir()

	store := NewGuestMetadataStore(tmpDir, nil)

	// Load from nonexistent file should not error
	err := store.Load()
	if err != nil {
		t.Errorf("Load from nonexistent file should not error: %v", err)
	}
}

func TestGuestMetadataStore_Load_InvalidJSON(t *testing.T) {
	tmpDir := t.TempDir()

	// Write invalid JSON
	filePath := filepath.Join(tmpDir, "guest_metadata.json")
	if err := os.WriteFile(filePath, []byte("{invalid json"), 0644); err != nil {
		t.Fatalf("Failed to write test file: %v", err)
	}

	store := NewGuestMetadataStore(tmpDir, nil)

	err := store.Load()
	if err == nil {
		t.Error("Load with invalid JSON should return error")
	}
}

func TestGuestMetadataStore_Save_CreatesDirectory(t *testing.T) {
	tmpDir := t.TempDir()
	subDir := filepath.Join(tmpDir, "nested", "dir")

	store := NewGuestMetadataStore(subDir, nil)

	// Set should create directory and save
	err := store.Set("id1", &GuestMetadata{CustomURL: "url1"})
	if err != nil {
		t.Fatalf("Set failed: %v", err)
	}

	// Verify file exists
	filePath := filepath.Join(subDir, "guest_metadata.json")
	if _, err := os.Stat(filePath); os.IsNotExist(err) {
		t.Error("Save should create directory and file")
	}
}

func TestGuestMetadataStore_Save_AtomicWrite(t *testing.T) {
	tmpDir := t.TempDir()

	store := NewGuestMetadataStore(tmpDir, nil)

	// Set some data
	err := store.Set("id1", &GuestMetadata{CustomURL: "url1"})
	if err != nil {
		t.Fatalf("Set failed: %v", err)
	}

	// Verify no temp file left behind
	tempFile := filepath.Join(tmpDir, "guest_metadata.json.tmp")
	if _, err := os.Stat(tempFile); !os.IsNotExist(err) {
		t.Error("Temp file should be removed after successful save")
	}
}

func TestGuestMetadataStore_RoundTrip(t *testing.T) {
	tmpDir := t.TempDir()

	// Create store and add data
	store := NewGuestMetadataStore(tmpDir, nil)

	err := store.Set("pve1:node1:100", &GuestMetadata{
		CustomURL:     "http://vm.local",
		Description:   "Test VM",
		Tags:          []string{"prod", "web"},
		LastKnownName: "webserver",
		LastKnownType: "qemu",
	})
	if err != nil {
		t.Fatalf("Set failed: %v", err)
	}

	// Create new store and load
	store2 := NewGuestMetadataStore(tmpDir, nil)
	err = store2.Load()
	if err != nil {
		t.Fatalf("Load failed: %v", err)
	}

	// Verify metadata
	meta := store2.Get("pve1:node1:100")
	if meta == nil {
		t.Fatal("Metadata not loaded")
	}
	if meta.CustomURL != "http://vm.local" {
		t.Errorf("CustomURL = %q, want %q", meta.CustomURL, "http://vm.local")
	}
	if meta.Description != "Test VM" {
		t.Errorf("Description = %q, want %q", meta.Description, "Test VM")
	}
	if len(meta.Tags) != 2 || meta.Tags[0] != "prod" || meta.Tags[1] != "web" {
		t.Errorf("Tags = %v, want [prod web]", meta.Tags)
	}
	if meta.LastKnownName != "webserver" {
		t.Errorf("LastKnownName = %q, want %q", meta.LastKnownName, "webserver")
	}
	if meta.LastKnownType != "qemu" {
		t.Errorf("LastKnownType = %q, want %q", meta.LastKnownType, "qemu")
	}
}

func TestGuestMetadata_Fields(t *testing.T) {
	meta := GuestMetadata{
		ID:            "pve1:node1:100",
		CustomURL:     "http://app.local:8080",
		Description:   "My virtual machine",
		Tags:          []string{"production", "database"},
		LastKnownName: "db-server",
		LastKnownType: "qemu",
	}

	if meta.ID != "pve1:node1:100" {
		t.Errorf("ID = %q, want %q", meta.ID, "pve1:node1:100")
	}
	if meta.CustomURL != "http://app.local:8080" {
		t.Errorf("CustomURL = %q, want %q", meta.CustomURL, "http://app.local:8080")
	}
	if meta.Description != "My virtual machine" {
		t.Errorf("Description = %q, want %q", meta.Description, "My virtual machine")
	}
	if len(meta.Tags) != 2 {
		t.Errorf("Tags count = %d, want 2", len(meta.Tags))
	}
	if meta.LastKnownName != "db-server" {
		t.Errorf("LastKnownName = %q, want %q", meta.LastKnownName, "db-server")
	}
	if meta.LastKnownType != "qemu" {
		t.Errorf("LastKnownType = %q, want %q", meta.LastKnownType, "qemu")
	}
}

func TestGuestMetadataStore_ConcurrentAccess(t *testing.T) {
	tmpDir := t.TempDir()
	store := NewGuestMetadataStore(tmpDir, nil)

	// Pre-populate
	store.metadata["id1"] = &GuestMetadata{ID: "id1", CustomURL: "url1"}

	// Concurrent reads should not panic
	done := make(chan bool)
	for i := 0; i < 10; i++ {
		go func() {
			store.Get("id1")
			store.GetAll()
			done <- true
		}()
	}

	for i := 0; i < 10; i++ {
		<-done
	}
}

func TestGuestMetadataStore_GetWithLegacyMigration_ExistingNewFormat(t *testing.T) {
	tmpDir := t.TempDir()
	store := NewGuestMetadataStore(tmpDir, nil)

	// Add metadata with new format ID
	store.metadata["pve1:node1:100"] = &GuestMetadata{
		ID:        "pve1:node1:100",
		CustomURL: "http://example.com",
	}

	// Get with new format should return directly
	result := store.GetWithLegacyMigration("pve1:node1:100", "pve1", "node1", 100)
	if result == nil {
		t.Fatal("Should return metadata for existing new format ID")
	}
	if result.CustomURL != "http://example.com" {
		t.Errorf("CustomURL = %q, want %q", result.CustomURL, "http://example.com")
	}
}

func TestGuestMetadataStore_GetWithLegacyMigration_ClusteredLegacy(t *testing.T) {
	tmpDir := t.TempDir()
	store := NewGuestMetadataStore(tmpDir, nil)

	// Add metadata with legacy clustered format: instance-node-VMID
	store.metadata["pve1-node1-100"] = &GuestMetadata{
		ID:        "pve1-node1-100",
		CustomURL: "http://legacy.com",
	}

	// Get with new format should migrate
	result := store.GetWithLegacyMigration("pve1:node1:100", "pve1", "node1", 100)
	if result == nil {
		t.Fatal("Should migrate and return metadata")
	}
	if result.CustomURL != "http://legacy.com" {
		t.Errorf("CustomURL = %q, want %q", result.CustomURL, "http://legacy.com")
	}

	// ID should be updated to new format
	if result.ID != "pve1:node1:100" {
		t.Errorf("ID = %q, want %q", result.ID, "pve1:node1:100")
	}

	// Old ID should be removed
	if store.metadata["pve1-node1-100"] != nil {
		t.Error("Legacy ID should be removed after migration")
	}

	// New ID should exist
	if store.metadata["pve1:node1:100"] == nil {
		t.Error("New ID should exist after migration")
	}

	// Migration should be persisted before returning.
	data, err := os.ReadFile(filepath.Join(tmpDir, "guest_metadata.json"))
	if err != nil {
		t.Fatalf("failed to read guest metadata file after migration: %v", err)
	}
	var persisted map[string]*GuestMetadata
	if err := json.Unmarshal(data, &persisted); err != nil {
		t.Fatalf("failed to decode guest metadata file after migration: %v", err)
	}
	if persisted["pve1-node1-100"] != nil {
		t.Error("Persisted metadata should not include legacy ID after migration")
	}
	if persisted["pve1:node1:100"] == nil {
		t.Error("Persisted metadata should include migrated ID")
	}
}

func TestGuestMetadataStore_GetWithLegacyMigration_StandaloneLegacy(t *testing.T) {
	tmpDir := t.TempDir()
	store := NewGuestMetadataStore(tmpDir, nil)

	// Add metadata with legacy standalone format: node-VMID
	store.metadata["node1-100"] = &GuestMetadata{
		ID:        "node1-100",
		CustomURL: "http://standalone.com",
	}

	// Get with instance == node (standalone) should migrate
	result := store.GetWithLegacyMigration("node1:node1:100", "node1", "node1", 100)
	if result == nil {
		t.Fatal("Should migrate and return metadata")
	}
	if result.CustomURL != "http://standalone.com" {
		t.Errorf("CustomURL = %q, want %q", result.CustomURL, "http://standalone.com")
	}

	// ID should be updated
	if result.ID != "node1:node1:100" {
		t.Errorf("ID = %q, want %q", result.ID, "node1:node1:100")
	}

	// Old ID should be removed
	if store.metadata["node1-100"] != nil {
		t.Error("Legacy ID should be removed after migration")
	}
}

func TestGuestMetadataStore_GetWithLegacyMigration_NotFound(t *testing.T) {
	tmpDir := t.TempDir()
	store := NewGuestMetadataStore(tmpDir, nil)

	// Get non-existent should return nil
	result := store.GetWithLegacyMigration("pve1:node1:100", "pve1", "node1", 100)
	if result != nil {
		t.Error("Should return nil for non-existent metadata")
	}
}

func TestGuestMetadataStore_GetWithLegacyMigration_ClusteredMatchesNodeFormat(t *testing.T) {
	tmpDir := t.TempDir()
	store := NewGuestMetadataStore(tmpDir, nil)

	// Add node-vmid format (legacy standalone format)
	store.metadata["node1-100"] = &GuestMetadata{
		ID:        "node1-100",
		CustomURL: "http://standalone.com",
	}

	// Clustered request (instance != node) CAN match node-vmid as fallback
	// This handles cases where metadata was created with old format
	result := store.GetWithLegacyMigration("pve1:node1:100", "pve1", "node1", 100)
	if result == nil {
		t.Fatal("Should migrate from node-vmid format for clustered request")
	}
	if result.CustomURL != "http://standalone.com" {
		t.Errorf("CustomURL = %q, want %q", result.CustomURL, "http://standalone.com")
	}
	if result.ID != "pve1:node1:100" {
		t.Errorf("ID = %q, want %q", result.ID, "pve1:node1:100")
	}

}

func TestGuestMetadataStore_GetWithLegacyMigration_ConcurrentMigration(t *testing.T) {
	tmpDir := t.TempDir()
	store := NewGuestMetadataStore(tmpDir, nil)

	// Add legacy metadata
	store.metadata["pve1-node1-100"] = &GuestMetadata{
		ID:        "pve1-node1-100",
		CustomURL: "http://legacy.com",
	}

	// Multiple concurrent migrations should not panic
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			store.GetWithLegacyMigration("pve1:node1:100", "pve1", "node1", 100)
		}()
	}
	wg.Wait()

	// New ID should exist
	if store.metadata["pve1:node1:100"] == nil {
		t.Error("New ID should exist after migration")
	}
}

func TestGuestMetadataStoreUpdateAllAppliesOneWorkingSet(t *testing.T) {
	store := NewGuestMetadataStore(t.TempDir(), nil)
	if err := store.Set("old", &GuestMetadata{CustomURL: "https://old.internal"}); err != nil {
		t.Fatalf("seed metadata: %v", err)
	}

	if err := store.UpdateAll(func(metadata map[string]*GuestMetadata) bool {
		metadata["new"] = metadata["old"]
		delete(metadata, "old")
		return true
	}); err != nil {
		t.Fatalf("UpdateAll: %v", err)
	}

	if store.Get("old") != nil {
		t.Fatal("old metadata key still exists")
	}
	if meta := store.Get("new"); meta == nil || meta.ID != "new" || meta.CustomURL != "https://old.internal" {
		t.Fatalf("new metadata = %#v", meta)
	}

	reloaded := NewGuestMetadataStore(store.dataPath, nil)
	if reloaded.Get("old") != nil {
		t.Fatal("persisted old metadata key still exists")
	}
	if meta := reloaded.Get("new"); meta == nil || meta.ID != "new" || meta.CustomURL != "https://old.internal" {
		t.Fatalf("persisted new metadata = %#v", meta)
	}
}

func TestGuestMetadataStoreUpdateAllRollsBackFailedPersistence(t *testing.T) {
	store := NewGuestMetadataStore(t.TempDir(), nil)
	if err := store.Set("old", &GuestMetadata{CustomURL: "https://old.internal"}); err != nil {
		t.Fatalf("seed metadata: %v", err)
	}

	badPath := filepath.Join(t.TempDir(), "not-a-directory")
	if err := os.WriteFile(badPath, []byte("occupied"), 0o600); err != nil {
		t.Fatalf("create invalid data path: %v", err)
	}
	store.dataPath = badPath

	err := store.UpdateAll(func(metadata map[string]*GuestMetadata) bool {
		metadata["new"] = metadata["old"]
		delete(metadata, "old")
		return true
	})
	if err == nil {
		t.Fatal("expected persistence error")
	}
	if meta := store.Get("old"); meta == nil || meta.CustomURL != "https://old.internal" {
		t.Fatalf("rolled-back old metadata = %#v", meta)
	}
	if meta := store.Get("new"); meta != nil {
		t.Fatalf("failed update remained in memory: %#v", meta)
	}
}

// Issue #1669: a guest migrating to another cluster node keeps its VMID but
// gets a new node-scoped ID, which orphaned its metadata (custom URL, tags,
// notes). The store must follow the guest across nodes.
func TestGuestMetadataStore_GetWithLegacyMigration_NodeMigration(t *testing.T) {
	tmpDir := t.TempDir()
	store := NewGuestMetadataStore(tmpDir, nil)

	store.metadata["pve1:node1:100"] = &GuestMetadata{
		ID:        "pve1:node1:100",
		CustomURL: "http://haos.example",
		Tags:      []string{"prod"},
	}

	// The guest moved from node1 to node2.
	result := store.GetWithLegacyMigration("pve1:node2:100", "pve1", "node2", 100)
	if result == nil {
		t.Fatal("expected metadata to follow the guest to its new node")
	}
	if result.CustomURL != "http://haos.example" {
		t.Errorf("CustomURL = %q, want %q", result.CustomURL, "http://haos.example")
	}
	if result.ID != "pve1:node2:100" {
		t.Errorf("migrated ID = %q, want %q", result.ID, "pve1:node2:100")
	}
	if store.Get("pve1:node1:100") != nil {
		t.Error("expected old node-scoped entry to be removed after migration")
	}
}

// A different VMID or a different instance must never be treated as the same
// guest.
func TestGuestMetadataStore_GetWithLegacyMigration_NodeMigrationDoesNotCrossGuests(t *testing.T) {
	tmpDir := t.TempDir()
	store := NewGuestMetadataStore(tmpDir, nil)

	store.metadata["pve1:node1:101"] = &GuestMetadata{ID: "pve1:node1:101", CustomURL: "http://other-guest"}
	store.metadata["pve2:node1:100"] = &GuestMetadata{ID: "pve2:node1:100", CustomURL: "http://other-instance"}

	if result := store.GetWithLegacyMigration("pve1:node2:100", "pve1", "node2", 100); result != nil {
		t.Fatalf("expected no migration across guests, got %+v", result)
	}
	if store.Get("pve1:node1:101") == nil || store.Get("pve2:node1:100") == nil {
		t.Error("unrelated entries must remain untouched")
	}
}

// A queued async write must be observable on disk once the store reports it has
// drained. Before the store owned these writes, callers detached their own
// goroutines, so a write could land after shutdown and after the data directory
// was being removed, leaving a stray guest_metadata.json.tmp behind.
func TestGuestMetadataStore_WaitForPendingWritesDrainsQueuedWrites(t *testing.T) {
	dataDir := t.TempDir()
	store := NewGuestMetadataStore(dataDir, nil)

	for i := range 25 {
		store.SetAsync("node:10"+string(rune('a'+i%25)), &GuestMetadata{
			ID:            "guest",
			LastKnownName: "vm-" + string(rune('a'+i%25)),
			LastKnownType: "qemu",
		})
	}

	if !store.WaitForPendingWrites(10 * time.Second) {
		t.Fatal("store did not drain within the timeout")
	}

	// Nothing may still be writing: a leftover .tmp means an atomic write was
	// in flight when the store claimed to be drained.
	entries, err := os.ReadDir(dataDir)
	if err != nil {
		t.Fatalf("read data dir: %v", err)
	}
	for _, entry := range entries {
		if filepath.Ext(entry.Name()) == ".tmp" {
			t.Fatalf("temporary file %q survived the drain; a write was still in flight", entry.Name())
		}
	}
	if _, err := os.Stat(filepath.Join(dataDir, "guest_metadata.json")); err != nil {
		t.Fatalf("guest metadata was not persisted: %v", err)
	}
}

// The data directory must be removable immediately after a drain. This is the
// exact property whose absence made TestHostedTenantAgentInstallTokenCannotReportToOtherTenant
// fail its t.TempDir cleanup with "directory not empty".
func TestGuestMetadataStore_DataDirIsRemovableAfterDrain(t *testing.T) {
	root := t.TempDir()
	dataDir := filepath.Join(root, "orgs", "client-b")
	if err := os.MkdirAll(dataDir, 0o755); err != nil {
		t.Fatalf("mkdir: %v", err)
	}

	store := NewGuestMetadataStore(dataDir, nil)
	for i := range 25 {
		store.SetAsync("node:20"+string(rune('a'+i%25)), &GuestMetadata{
			ID:            "guest",
			LastKnownName: "ct-" + string(rune('a'+i%25)),
			LastKnownType: "lxc",
		})
	}

	if !store.WaitForPendingWrites(10 * time.Second) {
		t.Fatal("store did not drain within the timeout")
	}
	if err := os.RemoveAll(filepath.Join(root, "orgs")); err != nil {
		t.Fatalf("org directory was not removable after drain: %v", err)
	}
}

func TestGuestMetadataStore_WaitOnNilStoreAndIdleStoreReturnTrue(t *testing.T) {
	var nilStore *GuestMetadataStore
	if !nilStore.WaitForPendingWrites(time.Second) {
		t.Fatal("nil store must report drained")
	}
	if !NewGuestMetadataStore(t.TempDir(), nil).WaitForPendingWrites(time.Second) {
		t.Fatal("idle store must report drained")
	}
}