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.

25.5 KB
Raw Blame
package hostagent

import (
	"compress/gzip"
	"context"
	"encoding/json"
	"encoding/pem"
	"errors"
	"fmt"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"runtime"
	"strings"
	"sync"
	"sync/atomic"
	"testing"
	"time"

	"github.com/rcourtman/pulse-go-rewrite/internal/hostmetrics"
	agentshost "github.com/rcourtman/pulse-go-rewrite/pkg/agents/host"
	"github.com/rs/zerolog"
	gohost "github.com/shirou/gopsutil/v4/host"
)

// realFSCollector returns a mockCollector wired to real filesystem operations.
func realFSCollector() *mockCollector {
	return &mockCollector{
		readFileFn:  func(name string) ([]byte, error) { return os.ReadFile(name) },
		writeFileFn: func(name string, data []byte, perm os.FileMode) error { return os.WriteFile(name, data, perm) },
		mkdirAllFn:  func(path string, perm os.FileMode) error { return os.MkdirAll(path, perm) },
		chmodFn:     func(name string, mode os.FileMode) error { return os.Chmod(name, mode) },
	}
}

func TestEnroll_Success(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != enrollEndpoint {
			t.Fatalf("unexpected path: %s", r.URL.Path)
		}
		if r.Method != http.MethodPost {
			t.Fatalf("unexpected method: %s", r.Method)
		}

		var req enrollPayload
		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
			t.Fatalf("decode request: %v", err)
		}
		if req.Hostname != "test-host" {
			t.Errorf("expected hostname test-host, got %s", req.Hostname)
		}
		if !req.CommandsEnabled {
			t.Error("expected commandsEnabled to be true")
		}

		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(enrollResponse{
			AgentID:        "host-test-host",
			RuntimeToken:   "runtime-tok-123",
			RuntimeTokenID: "tok-id-456",
			ReportInterval: "30s",
		})
	}))
	defer server.Close()

	stateDir := t.TempDir()
	logger := zerolog.New(zerolog.NewTestWriter(t))

	agent := &Agent{
		cfg: Config{
			APIToken:       "bootstrap-tok",
			EnableCommands: true,
			Enroll:         true,
		},
		logger:          logger,
		httpClient:      server.Client(),
		hostname:        "test-host",
		osName:          "linux",
		architecture:    "amd64",
		agentVersion:    "1.0.0",
		trimmedPulseURL: server.URL,
		stateDir:        stateDir,
		collector:       realFSCollector(),
	}

	err := agent.runEnrollmentLoop(context.Background())
	if err != nil {
		t.Fatalf("enrollment failed: %v", err)
	}

	// Verify token was updated.
	if agent.cfg.APIToken != "runtime-tok-123" {
		t.Errorf("expected token runtime-tok-123, got %s", agent.cfg.APIToken)
	}
	if agent.agentID != "host-test-host" || agent.cfg.AgentID != "host-test-host" {
		t.Fatalf("running agent identity was not updated after enrollment: agent=%q config=%q", agent.agentID, agent.cfg.AgentID)
	}

	// Verify runtime token was persisted.
	tokenPath := filepath.Join(stateDir, runtimeTokenFile)
	data, err := os.ReadFile(tokenPath)
	if err != nil {
		t.Fatalf("read runtime token file: %v", err)
	}
	if string(data) != "runtime-tok-123" {
		t.Errorf("expected persisted token runtime-tok-123, got %s", string(data))
	}

	// Verify agent-id was persisted.
	agentIDPath := filepath.Join(stateDir, "agent-id")
	data, err = os.ReadFile(agentIDPath)
	if err != nil {
		t.Fatalf("read agent-id file: %v", err)
	}
	if string(data) != "host-test-host" {
		t.Errorf("expected agent-id host-test-host, got %s", string(data))
	}
}

func TestEnroll_PrefersAgentIDFromResponse(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(enrollResponse{
			AgentID:      "agent-canonical",
			RuntimeToken: "runtime-tok-123",
		})
	}))
	defer server.Close()

	stateDir := t.TempDir()
	logger := zerolog.New(zerolog.NewTestWriter(t))

	agent := &Agent{
		cfg: Config{
			APIToken: "bootstrap-tok",
			Enroll:   true,
		},
		logger:          logger,
		httpClient:      server.Client(),
		hostname:        "test-host",
		osName:          "linux",
		architecture:    "amd64",
		agentVersion:    "1.0.0",
		trimmedPulseURL: server.URL,
		stateDir:        stateDir,
		collector:       realFSCollector(),
	}

	if err := agent.runEnrollmentLoop(context.Background()); err != nil {
		t.Fatalf("enrollment failed: %v", err)
	}

	agentIDPath := filepath.Join(stateDir, "agent-id")
	data, err := os.ReadFile(agentIDPath)
	if err != nil {
		t.Fatalf("read agent-id file: %v", err)
	}
	if got := string(data); got != "agent-canonical" {
		t.Fatalf("expected persisted agent-id agent-canonical, got %s", got)
	}
}

func TestEnroll_AlreadyEnrolled(t *testing.T) {
	stateDir := t.TempDir()

	// Write an existing runtime token.
	tokenPath := filepath.Join(stateDir, runtimeTokenFile)
	if err := os.WriteFile(tokenPath, []byte("existing-runtime-tok"), 0600); err != nil {
		t.Fatal(err)
	}

	logger := zerolog.New(zerolog.NewTestWriter(t))

	agent := &Agent{
		cfg: Config{
			APIToken: "bootstrap-tok",
			Enroll:   true,
		},
		logger:   logger,
		stateDir: stateDir,
		collector: &mockCollector{
			readFileFn: func(name string) ([]byte, error) {
				return os.ReadFile(name)
			},
		},
	}

	err := agent.runEnrollmentLoop(context.Background())
	if err != nil {
		t.Fatalf("enrollment failed: %v", err)
	}

	// Should use the existing runtime token.
	if agent.cfg.APIToken != "existing-runtime-tok" {
		t.Errorf("expected token existing-runtime-tok, got %s", agent.cfg.APIToken)
	}
}

func TestEnroll_403_SkipsEnrollment(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		http.Error(w, "Forbidden", http.StatusForbidden)
	}))
	defer server.Close()

	logger := zerolog.New(zerolog.NewTestWriter(t))

	agent := &Agent{
		cfg: Config{
			APIToken: "manual-install-tok",
			Enroll:   true,
		},
		logger:          logger,
		httpClient:      server.Client(),
		hostname:        "test-host",
		trimmedPulseURL: server.URL,
		stateDir:        t.TempDir(),
		collector:       &mockCollector{},
	}

	err := agent.runEnrollmentLoop(context.Background())
	if err != nil {
		t.Fatalf("enrollment should skip on 403, got error: %v", err)
	}

	// Token should remain unchanged.
	if agent.cfg.APIToken != "manual-install-tok" {
		t.Errorf("expected token unchanged, got %s", agent.cfg.APIToken)
	}
}

func TestEnroll_RetryThenSuccess(t *testing.T) {
	// Speed up retries for this test.
	origInitial := enrollInitialDelay
	origMax := enrollMaxDelay
	enrollInitialDelay = 10 * time.Millisecond
	enrollMaxDelay = 50 * time.Millisecond
	defer func() {
		enrollInitialDelay = origInitial
		enrollMaxDelay = origMax
	}()

	var attempts atomic.Int32

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		n := attempts.Add(1)
		if n < 3 {
			http.Error(w, "Service Unavailable", http.StatusServiceUnavailable)
			return
		}
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(enrollResponse{
			AgentID:      "host-retry",
			RuntimeToken: "runtime-after-retry",
		})
	}))
	defer server.Close()

	logger := zerolog.New(zerolog.NewTestWriter(t))

	agent := &Agent{
		cfg: Config{
			APIToken: "bootstrap-tok",
			Enroll:   true,
		},
		logger:          logger,
		httpClient:      server.Client(),
		hostname:        "retry-host",
		trimmedPulseURL: server.URL,
		stateDir:        t.TempDir(),
		collector:       &mockCollector{},
	}

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	err := agent.runEnrollmentLoop(ctx)
	if err != nil {
		t.Fatalf("enrollment should succeed after retries, got: %v", err)
	}

	if agent.cfg.APIToken != "runtime-after-retry" {
		t.Errorf("expected token runtime-after-retry, got %s", agent.cfg.APIToken)
	}

	if got := attempts.Load(); got < 3 {
		t.Errorf("expected at least 3 attempts, got %d", got)
	}
}

func TestEnroll_ContextCancelled(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		http.Error(w, "Service Unavailable", http.StatusServiceUnavailable)
	}))
	defer server.Close()

	logger := zerolog.New(zerolog.NewTestWriter(t))

	agent := &Agent{
		cfg: Config{
			APIToken: "bootstrap-tok",
			Enroll:   true,
		},
		logger:          logger,
		httpClient:      server.Client(),
		hostname:        "cancel-host",
		trimmedPulseURL: server.URL,
		stateDir:        t.TempDir(),
		collector:       &mockCollector{},
	}

	ctx, cancel := context.WithCancel(context.Background())
	// Cancel after a short delay.
	go func() {
		time.Sleep(100 * time.Millisecond)
		cancel()
	}()

	err := agent.runEnrollmentLoop(ctx)
	if err == nil {
		t.Fatal("expected error from cancelled context")
	}
}

func TestEnrollStatusError(t *testing.T) {
	err := &enrollStatusError{StatusCode: 401, Body: "Unauthorized"}
	expected := "enrollment returned HTTP 401: Unauthorized"
	if err.Error() != expected {
		t.Errorf("expected %q, got %q", expected, err.Error())
	}
}

func TestEnroll_401_PermanentFailure(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		http.Error(w, "Unauthorized", http.StatusUnauthorized)
	}))
	defer server.Close()

	logger := zerolog.New(zerolog.NewTestWriter(t))

	agent := &Agent{
		cfg: Config{
			APIToken: "expired-bootstrap-tok",
			Enroll:   true,
		},
		logger:          logger,
		httpClient:      server.Client(),
		hostname:        "test-host",
		trimmedPulseURL: server.URL,
		stateDir:        t.TempDir(),
		collector:       &mockCollector{},
	}

	err := agent.runEnrollmentLoop(context.Background())
	if err == nil {
		t.Fatal("expected error for 401 permanent failure")
	}
	if !strings.Contains(err.Error(), "401") {
		t.Errorf("expected 401 in error, got: %v", err)
	}
}

func TestEnroll_409_PermanentFailure(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		http.Error(w, "Conflict", http.StatusConflict)
	}))
	defer server.Close()

	logger := zerolog.New(zerolog.NewTestWriter(t))

	agent := &Agent{
		cfg: Config{
			APIToken: "consumed-bootstrap-tok",
			Enroll:   true,
		},
		logger:          logger,
		httpClient:      server.Client(),
		hostname:        "test-host",
		trimmedPulseURL: server.URL,
		stateDir:        t.TempDir(),
		collector:       &mockCollector{},
	}

	err := agent.runEnrollmentLoop(context.Background())
	if err == nil {
		t.Fatal("expected error for 409 permanent failure")
	}
	if !strings.Contains(err.Error(), "409") {
		t.Errorf("expected 409 in error, got: %v", err)
	}
}

func TestEnroll_MissingRuntimeToken(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		// Return a response missing runtimeToken.
		fmt.Fprint(w, `{"agentId":"agent-1"}`)
	}))
	defer server.Close()

	logger := zerolog.New(zerolog.NewTestWriter(t))

	agent := &Agent{
		cfg: Config{
			APIToken: "bootstrap-tok",
		},
		logger:          logger,
		httpClient:      server.Client(),
		hostname:        "test-host",
		trimmedPulseURL: server.URL,
		stateDir:        t.TempDir(),
		collector:       &mockCollector{},
	}

	_, err := agent.enroll(context.Background())
	if err == nil {
		t.Fatal("expected error for missing runtimeToken")
	}
}

func enrollmentTestCollector(hostname string) *mockCollector {
	collector := realFSCollector()
	collector.goos = "darwin" // keep OS identity on HostInfo, not the test machine's files
	collector.hostInfoFn = func(context.Context) (*gohost.InfoStat, error) {
		return &gohost.InfoStat{Hostname: hostname, Platform: "debian", KernelArch: "x86_64"}, nil
	}
	return collector
}

// A process that enrolls before building its modules must get back the
// runtime token and canonical agent ID, persisted where a restart finds them,
// and must present the same host identity New would report under.
func TestEnrollExchangesBootstrapTokenBeforeModulesStart(t *testing.T) {
	var gotPayload enrollPayload
	var gotAuth string
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != enrollEndpoint || r.Method != http.MethodPost {
			t.Fatalf("unexpected request %s %s", r.Method, r.URL.Path)
		}
		gotAuth = r.Header.Get("Authorization")
		if err := json.NewDecoder(r.Body).Decode(&gotPayload); err != nil {
			t.Fatalf("decode request: %v", err)
		}
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(enrollResponse{AgentID: "canonical-delly2", RuntimeToken: "runtime-tok"})
	}))
	defer server.Close()

	stateDir := t.TempDir()
	logger := zerolog.New(zerolog.NewTestWriter(t))
	result, err := Enroll(context.Background(), EnrollmentConfig{
		PulseURL:                server.URL,
		APIToken:                "bootstrap-tok",
		StateDir:                stateDir,
		HostnameOverride:        "delly2",
		AgentVersion:            "6.5.0",
		EnableCommands:          true,
		CommandAuthorityProfile: CommandAuthorityCommandCapable,
		Logger:                  &logger,
		Collector:               enrollmentTestCollector("ignored-by-override"),
	})
	if err != nil {
		t.Fatalf("Enroll() error = %v", err)
	}
	if result.APIToken != "runtime-tok" || result.AgentID != "canonical-delly2" {
		t.Fatalf("Enroll() = %+v, want runtime token and canonical agent ID", result)
	}
	if gotAuth != "Bearer bootstrap-tok" {
		t.Fatalf("enrollment authenticated with %q, want the bootstrap token", gotAuth)
	}
	want := enrollPayload{Hostname: "delly2", OS: "debian", Arch: "x86_64", AgentVersion: "6.5.0", CommandsEnabled: true}
	if gotPayload != want {
		t.Fatalf("enrollment payload = %+v, want %+v", gotPayload, want)
	}
	for file, want := range map[string]string{runtimeTokenFile: "runtime-tok", "agent-id": "canonical-delly2"} {
		data, err := os.ReadFile(filepath.Join(stateDir, file))
		if err != nil || string(data) != want {
			t.Fatalf("%s = %q (err %v), want %q", file, data, err, want)
		}
	}
}

// A monitoring-only install must not ask the server for command authority
// during enrollment, matching the ceiling New applies.
func TestEnrollHonoursMonitoringOnlyCommandCeiling(t *testing.T) {
	var gotPayload enrollPayload
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		json.NewDecoder(r.Body).Decode(&gotPayload)
		json.NewEncoder(w).Encode(enrollResponse{RuntimeToken: "runtime-tok"})
	}))
	defer server.Close()

	if _, err := Enroll(context.Background(), EnrollmentConfig{
		PulseURL:                server.URL,
		APIToken:                "bootstrap-tok",
		StateDir:                t.TempDir(),
		EnableCommands:          true,
		CommandAuthorityProfile: CommandAuthorityMonitoringOnly,
		Collector:               enrollmentTestCollector("pve-3"),
	}); err != nil {
		t.Fatalf("Enroll() error = %v", err)
	}
	if gotPayload.CommandsEnabled {
		t.Fatal("monitoring-only enrollment requested command authority")
	}
	if gotPayload.Hostname != "pve-3" {
		t.Fatalf("enrollment hostname = %q, want the discovered hostname", gotPayload.Hostname)
	}
}

// A restart with a persisted runtime token must not contact the server again.
func TestEnrollReusesPersistedRuntimeToken(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		t.Fatalf("persisted runtime token must not trigger an enrollment request")
	}))
	defer server.Close()

	stateDir := t.TempDir()
	if err := os.WriteFile(filepath.Join(stateDir, runtimeTokenFile), []byte("persisted-runtime-tok\n"), 0600); err != nil {
		t.Fatal(err)
	}
	result, err := Enroll(context.Background(), EnrollmentConfig{
		PulseURL:  server.URL,
		APIToken:  "bootstrap-tok",
		StateDir:  stateDir,
		Collector: enrollmentTestCollector("pve-3"),
	})
	if err != nil {
		t.Fatalf("Enroll() error = %v", err)
	}
	if result.APIToken != "persisted-runtime-tok" || result.AgentID != "" {
		t.Fatalf("Enroll() = %+v, want the persisted token and no new agent ID", result)
	}
}

func TestEnrollKeepsTokenTheServerSaysIsNotABootstrapToken(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		http.Error(w, "Forbidden", http.StatusForbidden)
	}))
	defer server.Close()

	result, err := Enroll(context.Background(), EnrollmentConfig{
		PulseURL:  server.URL,
		APIToken:  "manual-install-tok",
		StateDir:  t.TempDir(),
		Collector: enrollmentTestCollector("pve-3"),
	})
	if err != nil {
		t.Fatalf("Enroll() error = %v", err)
	}
	if result.APIToken != "manual-install-tok" || result.AgentID != "" {
		t.Fatalf("Enroll() = %+v, want the original token unchanged", result)
	}
}

func TestEnrollReturnsPermanentRejection(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		http.Error(w, "token already consumed", http.StatusConflict)
	}))
	defer server.Close()

	_, err := Enroll(context.Background(), EnrollmentConfig{
		PulseURL:  server.URL,
		APIToken:  "spent-bootstrap-tok",
		StateDir:  t.TempDir(),
		Collector: enrollmentTestCollector("pve-3"),
	})
	if err == nil || !strings.Contains(err.Error(), "409") {
		t.Fatalf("Enroll() error = %v, want the permanent 409 rejection", err)
	}
}

func TestEnrollRequiresToken(t *testing.T) {
	if _, err := Enroll(context.Background(), EnrollmentConfig{PulseURL: "http://127.0.0.1:7655"}); err == nil {
		t.Fatal("Enroll() without a token succeeded")
	}
}

// A restart that already holds a runtime token must not depend on host
// discovery: Docker- or Kubernetes-only agents never needed it to start.
func TestEnrollReusesPersistedRuntimeTokenWithoutHostDiscovery(t *testing.T) {
	stateDir := t.TempDir()
	if err := os.WriteFile(filepath.Join(stateDir, runtimeTokenFile), []byte("persisted-runtime-tok"), 0600); err != nil {
		t.Fatal(err)
	}
	collector := realFSCollector()
	collector.hostInfoFn = func(context.Context) (*gohost.InfoStat, error) {
		return nil, errors.New("host information unavailable")
	}

	result, err := Enroll(context.Background(), EnrollmentConfig{
		PulseURL:  "http://127.0.0.1:1",
		APIToken:  "bootstrap-tok",
		StateDir:  stateDir,
		Collector: collector,
	})
	if err != nil {
		t.Fatalf("Enroll() error = %v, want the persisted token without host discovery", err)
	}
	if result.APIToken != "persisted-runtime-tok" {
		t.Fatalf("Enroll() token = %q, want the persisted runtime token", result.APIToken)
	}
}

// The server binds the runtime token to the hostname presented at
// enrollment, so Enroll must present exactly the identity New reports under,
// including Linux distribution detection and the architecture fallback.
func TestEnrollPresentsTheIdentityNewReports(t *testing.T) {
	collector := &mockCollector{
		hostInfoFn: func(context.Context) (*gohost.InfoStat, error) {
			return &gohost.InfoStat{
				Hostname:        " pve-host ",
				HostID:          "hid",
				Platform:        "debian",
				PlatformFamily:  "debian",
				PlatformVersion: "13.4",
			}, nil
		},
		statFn: func(name string) (os.FileInfo, error) {
			if name == "/etc/pve" {
				return nil, nil
			}
			return nil, os.ErrNotExist
		},
		lookPathFn: func(file string) (string, error) {
			if file == "pveversion" {
				return "/usr/bin/pveversion", nil
			}
			return "", os.ErrNotExist
		},
		commandCombinedOutputFn: func(context.Context, string, ...string) (string, error) {
			return "pve-manager/9.1.9/ee7bad0a3d1546c9 (running kernel: 7.0.0-3-pve)", nil
		},
	}
	agent, err := New(Config{APIToken: "token", HostnameOverride: "  ", LogLevel: zerolog.InfoLevel, Collector: collector})
	if err != nil {
		t.Fatalf("New() error = %v", err)
	}

	var gotPayload enrollPayload
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		json.NewDecoder(r.Body).Decode(&gotPayload)
		json.NewEncoder(w).Encode(enrollResponse{RuntimeToken: "runtime-tok"})
	}))
	defer server.Close()
	if _, err := Enroll(context.Background(), EnrollmentConfig{
		PulseURL:         server.URL,
		APIToken:         "bootstrap-tok",
		StateDir:         t.TempDir(),
		HostnameOverride: "  ",
		Collector:        collector,
	}); err != nil {
		t.Fatalf("Enroll() error = %v", err)
	}

	if gotPayload.Hostname != agent.hostname || gotPayload.OS != agent.osName || gotPayload.Arch != agent.architecture {
		t.Fatalf("enrollment identity = %q/%q/%q, New reports %q/%q/%q",
			gotPayload.Hostname, gotPayload.OS, gotPayload.Arch, agent.hostname, agent.osName, agent.architecture)
	}
	if agent.hostname != "pve-host" || agent.osName != proxmoxPVEOSName || agent.architecture != runtime.GOARCH {
		t.Fatalf("New identity = %q/%q/%q, want the trimmed hostname, Proxmox VE, and the runtime architecture", agent.hostname, agent.osName, agent.architecture)
	}
}

// #2854: inject gopsutil's raspi-config heuristic, but read Debian's actual
// metadata through a real synthetic /etc -> /usr/lib symlink. Neither the
// reporter's Pi nor gopsutil's absolute-file heuristic is executed here.
func TestEnrollAndReportUseDebianOSReleaseIdentity(t *testing.T) {
	root := t.TempDir()
	for _, dir := range []string{"etc", "usr/lib"} {
		if err := os.MkdirAll(filepath.Join(root, dir), 0700); err != nil {
			t.Fatal(err)
		}
	}
	const release = "PRETTY_NAME=\"Debian GNU/Linux 13 (trixie)\"\nNAME=\"Debian GNU/Linux\"\nVERSION_ID=\"13\"\nDEBIAN_VERSION_FULL=13.7\nID=debian\n"
	if err := os.WriteFile(filepath.Join(root, "usr/lib/os-release"), []byte(release), 0600); err != nil {
		t.Fatal(err)
	}
	if err := os.Symlink("../usr/lib/os-release", filepath.Join(root, "etc/os-release")); err != nil {
		t.Fatal(err)
	}
	collector := realFSCollector()
	collector.goos = "linux"
	collector.hostInfoFn = func(context.Context) (*gohost.InfoStat, error) {
		return &gohost.InfoStat{
			Hostname: "pi-host", HostID: "synthetic-machine-id",
			Platform: "raspbian", PlatformFamily: "debian", PlatformVersion: "13.7",
			KernelArch: "aarch64",
		}, nil
	}
	collector.readFileFn = func(path string) ([]byte, error) {
		if path == "/etc/os-release" {
			return os.ReadFile(filepath.Join(root, "etc/os-release"))
		}
		if strings.HasPrefix(path, root+string(os.PathSeparator)) {
			return os.ReadFile(path)
		}
		return nil, os.ErrNotExist
	}
	collector.metricsFn = func(context.Context, []string) (hostmetrics.Snapshot, error) {
		return hostmetrics.Snapshot{CPUCount: 4, CPUUsagePercent: 7.5}, nil
	}
	var enrollment enrollPayload
	var received agentshost.Report
	var receiptMu sync.Mutex
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		receiptMu.Lock()
		defer receiptMu.Unlock()
		switch r.URL.Path {
		case enrollEndpoint:
			if r.Header.Get("Authorization") != "Bearer synthetic-bootstrap" {
				t.Error("enrollment credential changed")
			}
			if err := json.NewDecoder(r.Body).Decode(&enrollment); err != nil {
				t.Error(err)
				w.WriteHeader(http.StatusBadRequest)
				return
			}
			json.NewEncoder(w).Encode(enrollResponse{AgentID: "canonical-agent", RuntimeToken: "synthetic-runtime"})
		case agentReportEndpoint:
			if r.Header.Get("Authorization") != "Bearer synthetic-runtime" {
				t.Error("report credential changed")
			}
			reader, err := gzip.NewReader(r.Body)
			if err != nil {
				t.Error(err)
				w.WriteHeader(http.StatusBadRequest)
				return
			}
			defer reader.Close()
			if err := json.NewDecoder(reader).Decode(&received); err != nil {
				t.Error(err)
				w.WriteHeader(http.StatusBadRequest)
				return
			}
			json.NewEncoder(w).Encode(map[string]bool{"success": true})
		default:
			t.Errorf("unexpected request: %s", r.URL.Path)
			w.WriteHeader(http.StatusNotFound)
		}
	}))
	defer server.Close()
	caPath := filepath.Join(root, "test-ca.pem")
	if err := os.WriteFile(caPath, pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: server.Certificate().Raw}), 0600); err != nil {
		t.Fatal(err)
	}
	stateDir := filepath.Join(root, "state")
	result, err := Enroll(context.Background(), EnrollmentConfig{
		PulseURL: server.URL, APIToken: "synthetic-bootstrap", StateDir: stateDir,
		HostnameOverride: " pi-label ", Collector: collector, CACertPath: caPath,
	})
	if err != nil {
		t.Fatal(err)
	}
	agent, err := New(Config{
		PulseURL: server.URL, APIToken: result.APIToken, AgentID: result.AgentID,
		StateDir: stateDir, HostnameOverride: " pi-label ", Collector: collector,
		CACertPath: caPath, LogLevel: zerolog.Disabled, DisableCeph: true,
	})
	if err != nil {
		t.Fatal(err)
	}
	report, err := agent.buildReport(context.Background())
	if err != nil {
		t.Fatal(err)
	}
	if err := agent.sendReport(context.Background(), report); err != nil {
		t.Fatal(err)
	}
	receiptMu.Lock()
	defer receiptMu.Unlock()
	if received.Host.OSName != "debian" || received.Host.OSVersion != "13.7" {
		t.Fatalf("received OS = %q %q, want debian 13.7", received.Host.OSName, received.Host.OSVersion)
	}
	if received.Host.Hostname != "pi-label" || received.Host.MachineID != "synthetic-machine-id" || received.Host.Architecture != "aarch64" || received.Agent.ID != "canonical-agent" {
		t.Fatalf("host/agent identity changed: %+v / %q", received.Host, received.Agent.ID)
	}
	if enrollment.Hostname != received.Host.Hostname || enrollment.OS != received.Host.OSName || enrollment.Arch != received.Host.Architecture || enrollment.CommandsEnabled || received.Agent.CommandsEnabled {
		t.Fatalf("enrollment/report identity or commands-off control changed: %+v / %+v", enrollment, received.Agent)
	}
	if received.Host.CPUCount != 4 || received.Metrics.CPUUsagePercent != 7.5 {
		t.Fatal("OS identity correction changed collected metrics")
	}
	if saved, err := os.ReadFile(filepath.Join(stateDir, runtimeTokenFile)); err != nil || string(saved) != "synthetic-runtime" {
		t.Fatalf("saved synthetic credential changed: %q / %v", saved, err)
	}
	t.Logf("trusted synthetic enrollment/report: %s %s, hostname=%s, machine=%s, agent=%s, arch=%s, commands=false, CPU=7.5",
		received.Host.OSName, received.Host.OSVersion, received.Host.Hostname, received.Host.MachineID, received.Agent.ID, received.Host.Architecture)
}