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.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
Require complete Proxmox guest status observations
pulse-triage[bot]0d07a527244e
diff --git a/internal/monitoring/guest_status_http_test.go b/internal/monitoring/guest_status_http_test.gonew file mode 100644index 0000000000..d9d109a7e9--- /dev/null+++ b/internal/monitoring/guest_status_http_test.go@@ -0,0 +1,232 @@+package monitoring++import (+ "context"+ "encoding/json"+ "fmt"+ "net/http"+ "net/http/httptest"+ "strings"+ "sync/atomic"+ "testing"+ "time"++ "github.com/rcourtman/pulse-go-rewrite/internal/config"+ "github.com/rcourtman/pulse-go-rewrite/internal/models"+ "github.com/rcourtman/pulse-go-rewrite/internal/unifiedresources"+ "github.com/rcourtman/pulse-go-rewrite/pkg/proxmox"+)++// The independent control-plane observer must not turn an unfinished or+// contradictory status reply into proof of an action's outcome. No action,+// guest-agent operation or native failure is executed by these HTTP fixtures.+func TestGuestStatusHTTPActionObservation(t *testing.T) {+ for _, clientKind := range []string{"direct", "cluster"} {+ for _, kind := range []string{"qemu", "lxc"} {+ for _, rejection := range []string{"prefix", "truncated", "foreign", "conflicting-error"} {+ t.Run(clientKind+"/"+kind+"/"+rejection, func(t *testing.T) {+ var phase, statuses, commands atomic.Int32+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ switch {+ case strings.HasSuffix(r.URL.Path, "/nodes"):+ fmt.Fprint(w, `{"data":[{"node":"node","status":"online"}]}`)+ case strings.HasSuffix(r.URL.Path, "/status/current"):+ statuses.Add(1)+ body := `{"data":{"status":"running","uptime":42,"vmid":105}}`+ if phase.Load() == 1 {+ switch rejection {+ case "prefix":+ body += ` {"data":{"status":"stopped"}}`+ case "truncated":+ w.Header().Set("Content-Length", fmt.Sprint(len(body)+100))+ case "foreign":+ body = `{"data":{"status":"running","uptime":42,"vmid":106}}`+ case "conflicting-error":+ body = `{"data":{"status":"running","uptime":42},"errors":{"reason":"fixture-private-detail"}}`+ }+ } else if phase.Load() == 2 {+ body = `{"data":{"status":"stopped","uptime":0}}`+ }+ fmt.Fprint(w, body)+ default:+ commands.Add(1)+ t.Errorf("unexpected non-status operation: %s", r.URL.Path)+ http.NotFound(w, r)+ }+ }))+ defer server.Close()+ cfg := proxmox.ClientConfig{Host: server.URL, TokenName: "fixture@pve!pulse", TokenValue: "fixture", Timeout: guestPollFixtureHangGuard}+ var client PVEClientInterface+ if clientKind == "direct" {+ var err error+ client, err = proxmox.NewClient(cfg)+ if err != nil {+ t.Fatal(err)+ }+ } else {+ client = proxmox.NewClusterClient("status-observer", cfg, []string{server.URL}, nil)+ }+ m := &Monitor{pveClients: map[string]PVEClientInterface{"status-observer": client}}+ for step := int32(0); step < 3; step++ {+ phase.Store(step)+ before := statuses.Load()+ observation, err := m.ObserveProxmoxGuest(context.Background(), "status-observer", "node", 105, kind)+ if step == 1 {+ if err == nil || observation != (ProxmoxGuestObservation{}) {+ t.Errorf("unverified action observation: %+v err=%v", observation, err)+ }+ if err != nil && strings.Contains(err.Error(), "fixture-private-detail") {+ t.Error("response body escaped into observer error")+ }+ } else {+ state, uptime := "running", uint64(42)+ if step == 2 {+ state, uptime = "stopped", 0+ }+ if err != nil || observation.Status != state || observation.Uptime != uptime || observation.ObservedAt.IsZero() {+ t.Errorf("valid independent observation lost: %+v err=%v", observation, err)+ }+ }+ if statuses.Load()-before != 1 {+ t.Errorf("status admission added retry: %d", statuses.Load()-before)+ }+ }+ if commands.Load() != 0 {+ t.Error("observer added guest operations")+ }+ })+ }+ }+ }+}++type guestStatusHTTPFrame struct {+ Phase string `json:"phase"`+ VM models.VM `json:"vm"`+ Resources json.RawMessage `json:"resources"`+ MemoryHistory []MetricPoint `json:"memoryHistory"`+}++func guestStatusHTTPMonitoringJourney(t *testing.T, clientKind, collector, rejection string) []guestStatusHTTPFrame {+ t.Helper()+ const gib = uint64(1024 * 1024 * 1024)+ var phase, commands atomic.Int32+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ switch {+ case strings.HasSuffix(r.URL.Path, "/nodes"):+ fmt.Fprint(w, `{"data":[{"node":"node","status":"online"}]}`)+ case strings.HasSuffix(r.URL.Path, "/status/current"):+ available := uint64(0)+ if phase.Load() > 0 {+ available = 3 * gib+ }+ body := fmt.Sprintf(`{"data":{"status":"running","agent":0,"maxmem":%d,"mem":%d,"meminfo":{"total":%d,"available":%d},"uptime":42}}`, 8*gib, 8*gib, 4*gib, available)+ if phase.Load() == 1 || phase.Load() == 2 {+ switch rejection {+ case "prefix":+ body += ` {"data":null}`+ case "truncated":+ w.Header().Set("Content-Length", fmt.Sprint(len(body)+100))+ case "missing":+ body = `{}`+ case "conflicting-error":+ body = body[:len(body)-1] + `,"errors":{"message":"fixture-private-detail"}}`+ }+ }+ fmt.Fprint(w, body)+ default:+ commands.Add(1)+ t.Errorf("status-only fixture issued extra operation: %s", r.URL.Path)+ http.NotFound(w, r)+ }+ }))+ defer server.Close()+ cfg := proxmox.ClientConfig{Host: server.URL, TokenName: "fixture@pve!pulse", TokenValue: "fixture", Timeout: guestPollFixtureHangGuard}+ var client PVEClientInterface+ if clientKind == "direct" {+ var err error+ client, err = proxmox.NewClient(cfg)+ if err != nil {+ t.Fatal(err)+ }+ } else {+ client = proxmox.NewClusterClient("status-integrity", cfg, []string{server.URL}, nil)+ }+ m := &Monitor{config: &config.Config{}, rateTracker: NewRateTracker(), metricsHistory: NewMetricsHistory(32, time.Hour), guestMetadataLimiter: make(map[string]time.Time)}+ registry := unifiedresources.NewRegistry(nil)+ id := makeGuestID("status-integrity", "node", 105)+ previous := map[string]models.VM{}+ var frames []guestStatusHTTPFrame+ for step, name := range []string{"accepted-pressure", "unread-status", "repeated-unread", "recovered"} {+ phase.Store(int32(step))+ ctx, cancel := context.WithTimeout(context.Background(), guestPollFixtureHangGuard)+ cycleStart := time.Now()+ res := proxmox.ClusterResource{Type: "qemu", Node: "node", VMID: 105, Name: "status-integrity-guest", Status: "running", CPU: .2 + float64(step)/10, MaxMem: 8 * gib, Mem: 8 * gib, MaxDisk: gib}+ var vms []models.VM+ if collector == "cluster" {+ vms = m.collectClusterVMResources(ctx, "status-integrity", []indexedClusterResource{{resource: res, guestID: id}}, client, previous, nil)+ } else {+ vms, _ = m.pollNodeVMsWithClusterResourceBuilder(ctx, "status-integrity", "node", []proxmox.VM{{VMID: 105, Name: res.Name, Status: res.Status, CPU: res.CPU, MaxMem: res.MaxMem, Mem: res.Mem, MaxDisk: res.MaxDisk}}, client, previous, nil)+ }+ cancel()+ if len(vms) != 1 {+ t.Fatalf("collector lost independently listed guest: %d", len(vms))+ }+ vm := vms[0]+ m.recordGuestMetrics(vms, nil, cycleStart)+ registry.IngestSnapshot(models.StateSnapshot{VMs: vms})+ views := registry.VMs()+ if len(views) != 1 {+ t.Fatal("canonical projection lost guest")+ }+ if vm.CPU != res.CPU || vm.Status != "running" {+ t.Error("status rejection stopped independent guest telemetry")+ }+ switch step {+ case 0:+ if vm.Memory.Usage != 100 || vm.Memory.Observation.State != "current" || vm.Memory.Observation.Source != "available-field" {+ t.Fatalf("initial pressure did not establish evidence: %+v", vm.Memory)+ }+ case 1, 2:+ original := frames[0].VM.Memory+ if vm.Memory.Usage != 100 || vm.Memory.Observation.State != "last-known" || !vm.Memory.Observation.ObservedAt.Equal(original.Observation.ObservedAt) {+ t.Errorf("rejected status invented/renewed healthy memory: %+v", vm.Memory)+ }+ if views[0].MemoryEvidence(time.Now()).PressureKnown {+ t.Error("retained memory became current pressure")+ }+ if len(m.metricsHistory.GetGuestMetrics(id, "memory", time.Hour)) != 1 {+ t.Error("rejected status added current memory History")+ }+ case 3:+ if vm.Memory.Usage != 25 || vm.Memory.Observation.State != "current" {+ t.Errorf("valid later status did not recover: %+v", vm.Memory)+ }+ }+ front := m.buildBroadcastFrontendStateFromSnapshot(models.StateSnapshot{VMs: vms}, m.mockModeFence.begin())+ wire, err := json.Marshal(front.Resources)+ if err != nil {+ t.Fatal(err)+ }+ frames = append(frames, guestStatusHTTPFrame{Phase: name, VM: vm, Resources: wire, MemoryHistory: m.metricsHistory.GetGuestMetrics(id, "memory", time.Hour)})+ previous[id] = previousVMFromView(views[0])+ }+ if commands.Load() != 0 {+ t.Error("status rejection queued a guest operation")+ }+ history := m.metricsHistory.GetGuestMetrics(id, "memory", time.Hour)+ if len(history) != 2 || history[0].Value != 100 || history[1].Value != 25 {+ t.Errorf("History accepted rejected reading or lost recovery: %+v", history)+ }+ return frames+}++func TestGuestStatusHTTPMonitoringContract(t *testing.T) {+ for _, client := range []string{"direct", "cluster"} {+ for _, collector := range []string{"cluster", "node"} {+ for _, rejection := range []string{"prefix", "truncated", "missing", "conflicting-error"} {+ t.Run(client+"/"+collector+"/"+rejection, func(t *testing.T) { guestStatusHTTPMonitoringJourney(t, client, collector, rejection) })+ }+ }+ }+}diff --git a/pkg/proxmox/client.go b/pkg/proxmox/client.goindex c3b27c202c..82f2438cb8 100644--- a/pkg/proxmox/client.go+++ b/pkg/proxmox/client.go@@ -2479,18 +2479,12 @@ func (c *Client) GetVMStatus(ctx context.Context, node string, vmid int) (*VMStaif err != nil {return nil, err}- defer resp.Body.Close()-- var result struct {- Data VMStatus `json:"data"`- }-- if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {+ status, err := readGuestStatus[VMStatus](resp, vmid)+ if err != nil {return nil, err}-- result.Data.ObservedAt = time.Now().UTC()- return &result.Data, nil+ status.ObservedAt = time.Now().UTC()+ return status, nil}// GetContainerStatus returns detailed container status using real-time endpoint@@ -2499,18 +2493,12 @@ func (c *Client) GetContainerStatus(ctx context.Context, node string, vmid int)if err != nil {return nil, err}- defer resp.Body.Close()-- var result struct {- Data Container `json:"data"`- }-- if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {+ status, err := readGuestStatus[Container](resp, vmid)+ if err != nil {return nil, err}-- result.Data.ObservedAt = time.Now().UTC()- return &result.Data, nil+ status.ObservedAt = time.Now().UTC()+ return status, nil}// ClusterResource represents a resource from /cluster/resourcesdiff --git a/pkg/proxmox/guest_status_response.go b/pkg/proxmox/guest_status_response.gonew file mode 100644index 0000000000..73d231101c--- /dev/null+++ b/pkg/proxmox/guest_status_response.go@@ -0,0 +1,67 @@+package proxmox++import (+ "bytes"+ "encoding/json"+ "errors"+ "net/http"+ "strconv"+ "strings"+ "unicode/utf8"+)++// Status supports both monitoring samples and independent action observations.+// A decodable prefix is not a completed read; never include its body in errors.+var errInvalidGuestStatusResponse = errors.New("invalid Proxmox guest status response")++func readGuestStatus[T any](resp *http.Response, vmid int) (*T, error) {+ body, readErr := readResponseBodyLimited(resp.Body)+ closeErr := resp.Body.Close()+ if readErr != nil || closeErr != nil {+ return nil, errors.Join(readErr, closeErr)+ }+ if resp.StatusCode != http.StatusOK || !utf8.Valid(body) {+ return nil, errInvalidGuestStatusResponse+ }+ envelope, valid := inventoryResponseObject(body, "data", "errors")+ if !valid {+ return nil, errInvalidGuestStatusResponse+ }+ if failure, exists := envelope["errors"]; exists && !bytes.Equal(bytes.TrimSpace(failure), []byte("null")) {+ return nil, errInvalidGuestStatusResponse+ }+ fields := append([]string{"balloon", "balloon_min", "ballooninfo", "freemem", "meminfo"}, guestInventoryFields...)+ status, valid := inventoryResponseObject(envelope["data"], fields...)+ if !valid {+ return nil, errInvalidGuestStatusResponse+ }+ var state string+ if json.Unmarshal(status["status"], &state) != nil || strings.TrimSpace(state) == "" {+ return nil, errInvalidGuestStatusResponse+ }+ // PVE may omit vmid in this endpoint. If present, it must identify the+ // requested guest exactly; retain LXC's integer-string compatibility, but+ // do not let FlexInt's general numeric truncation accept a different ID.+ if raw, exists := status["vmid"]; exists {+ var id int+ if json.Unmarshal(raw, &id) != nil {+ var text string+ if json.Unmarshal(raw, &text) != nil {+ return nil, errInvalidGuestStatusResponse+ }+ var err error+ id, err = strconv.Atoi(text)+ if err != nil {+ return nil, errInvalidGuestStatusResponse+ }+ }+ if id <= 0 || id != vmid {+ return nil, errInvalidGuestStatusResponse+ }+ }+ var value T+ if json.Unmarshal(envelope["data"], &value) != nil {+ return nil, errInvalidGuestStatusResponse+ }+ return &value, nil+}diff --git a/pkg/proxmox/guest_status_response_test.go b/pkg/proxmox/guest_status_response_test.gonew file mode 100644index 0000000000..77612431d3--- /dev/null+++ b/pkg/proxmox/guest_status_response_test.go@@ -0,0 +1,190 @@+package proxmox++import (+ "context"+ "errors"+ "fmt"+ "io"+ "net/http"+ "net/http/httptest"+ "strings"+ "sync/atomic"+ "testing"+ "time"+)++func testReadGuestStatus(c *Client, kind string) (string, time.Time, bool, error) {+ if kind == "qemu" {+ value, err := c.GetVMStatus(context.Background(), "member", 105)+ if value == nil {+ return "", time.Time{}, true, err+ }+ return value.Status, value.ObservedAt, false, err+ }+ value, err := c.GetContainerStatus(context.Background(), "member", 105)+ if value == nil {+ return "", time.Time{}, true, err+ }+ return value.Status, value.ObservedAt, false, err+}++// Real HTTP reads: no malformed success may become a fresh guest observation.+func TestGuestStatusResponseAdmission(t *testing.T) {+ const valid = `{"data":{"status":"running","uptime":12,"netin":10}}`+ for _, kind := range []string{"qemu", "lxc"} {+ for _, tc := range []struct {+ name, body string+ truncated bool+ }{+ {"missing-data", `{}`, false},+ {"null-data", `{"data":null}`, false},+ {"null-envelope", `null`, false},+ {"array-data", `{"data":[]}`, false},+ {"empty-data", `{"data":{}}`, false},+ {"missing-state", `{"data":{"uptime":12}}`, false},+ {"null-state", `{"data":{"status":null}}`, false},+ {"empty-state", `{"data":{"status":" "}}`, false},+ {"wrong-state-type", `{"data":{"status":true}}`, false},+ {"case-data", `{"Data":{"status":"running"}}`, false},+ {"duplicate-data", `{"data":{"status":"stopped"},"data":{"status":"running"}}`, false},+ {"escaped-duplicate-data", `{"data":{"status":"stopped"},"\u0064ata":{"status":"running"}}`, false},+ {"case-overwrite", `{"data":{"status":"stopped"},"Data":{"status":"running"}}`, false},+ {"duplicate-state", `{"data":{"status":"stopped","status":"running"}}`, false},+ {"escaped-duplicate-state", `{"data":{"status":"stopped","\u0073tatus":"running"}}`, false},+ {"case-state", `{"data":{"status":"stopped","Status":"running"}}`, false},+ {"case-lock", `{"data":{"status":"running","Lock":"backup"}}`, false},+ {"duplicate-counter", `{"data":{"status":"running","netin":10,"netin":0}}`, false},+ {"case-counter", `{"data":{"status":"running","Netin":10}}`, false},+ {"case-memory", `{"data":{"status":"running","Meminfo":{"available":0}}}`, false},+ {"conflicting-error", `{"data":{"status":"running"},"errors":{"message":"fixture-private-detail"}}`, false},+ {"case-error", `{"data":{"status":"running"},"Errors":null}`, false},+ {"trailing-value", valid + ` {"data":{"status":"stopped"}}`, false},+ {"trailing-garbage", valid + `fixture-private-detail`, false},+ {"truncated-after-prefix", valid, true},+ {"oversized-after-prefix", valid + strings.Repeat(" ", int(maxResponseBodyBytes)), false},+ {"invalid-utf8", `{"data":{"status":"running"},"metadata":"` + string([]byte{0xff}) + `"}`, false},+ {"foreign-guest", `{"data":{"status":"running","vmid":106}}`, false},+ {"null-guest", `{"data":{"status":"running","vmid":null}}`, false},+ {"zero-guest", `{"data":{"status":"running","vmid":0}}`, false},+ {"fractional-guest", `{"data":{"status":"running","vmid":105.5}}`, false},+ {"fractional-string-guest", `{"data":{"status":"running","vmid":"105.5"}}`, false},+ {"duplicate-guest", `{"data":{"status":"running","vmid":106,"vmid":105}}`, false},+ {"invalid-value", `{"data":{"status":"running","uptime":"fixture-private-detail"}}`, false},+ } {+ t.Run(kind+"/"+tc.name, func(t *testing.T) {+ var requests atomic.Int32+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ requests.Add(1)+ if r.URL.Path != "/api2/json/nodes/member/"+kind+"/105/status/current" {+ t.Errorf("unexpected path: %s", r.URL.Path)+ }+ if tc.truncated {+ w.Header().Set("Content-Length", fmt.Sprint(len(tc.body)+100))+ }+ fmt.Fprint(w, tc.body)+ }))+ defer server.Close()+ _, at, nilResult, err := testReadGuestStatus(backupTestClient(t, server.URL), kind)+ if err == nil || !nilResult || !at.IsZero() {+ t.Errorf("unverified guest observation admitted: nil=%t time=%s err=%v", nilResult, at, err)+ }+ if err != nil && strings.Contains(err.Error(), "fixture-private-detail") {+ t.Error("response material leaked into diagnostic")+ }+ if requests.Load() != 1 {+ t.Errorf("invalid success replayed: %d", requests.Load())+ }+ })+ }+ }+}++func TestGuestStatusAcceptedCompatibility(t *testing.T) {+ for _, kind := range []string{"qemu", "lxc"} {+ for _, state := range []string{"running", "stopped", "paused", "future-provider-state"} {+ for _, identity := range []string{"", `,"vmid":105`, `,"vmid":"105"`} {+ t.Run(kind+"/"+state+identity, func(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ fmt.Fprintf(w, `{"data":{"status":%q%s,"provider-metadata":{"revision":1}},"errors":null,"total":1}`, state, identity)+ }))+ defer server.Close()+ before := time.Now()+ got, at, nilResult, err := testReadGuestStatus(backupTestClient(t, server.URL), kind)+ if err != nil || nilResult || got != state || at.Before(before) || at.After(time.Now()) {+ t.Fatalf("compatible state refused or incorrectly timed: %q %s nil=%t err=%v", got, at, nilResult, err)+ }+ })+ }+ }+ }+ t.Run("qemu-metrics", func(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ fmt.Fprint(w, `{"data":{"status":"running","cpu":0.25,"cpus":2,"mem":512,"maxmem":1024,"balloon":768,"balloon_min":256,"freemem":128,"meminfo":{"total":1024,"available":0},"ballooninfo":{"total_mem":1024,"free_mem":128},"disk":50,"maxdisk":100,"diskread":0,"diskwrite":null,"netin":32,"uptime":12,"agent":1,"lock":"backup"}}`)+ }))+ defer server.Close()+ got, err := backupTestClient(t, server.URL).GetVMStatus(context.Background(), "member", 105)+ if err != nil {+ t.Fatal(err)+ }+ if got.CPU != .25 || got.CPUs != 2 || got.Mem != 512 || got.MaxMem != 1024 || got.Balloon != 768 || got.BalloonMin != 256 || got.FreeMem != 128 || got.MemInfo == nil || !got.MemInfo.AvailabilityKnown || got.MemInfo.Available != 0 || got.BalloonInfo == nil || got.BalloonInfo.TotalMem != 1024 || got.Disk != 50 || got.MaxDisk != 100 || got.NetIn != 32 || got.Uptime != 12 || !got.Agent.IsEnabled() || got.Lock != "backup" {+ t.Fatalf("QEMU fields changed: %+v", got)+ }+ if got.IOCounters != (IOCounterPresence{Explicit: true, DiskRead: true, NetworkIn: true}) {+ t.Fatalf("missing/null/zero counter semantics changed: %+v", got.IOCounters)+ }+ })+ t.Run("lxc-metrics", func(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ fmt.Fprint(w, `{"data":{"status":"running","vmid":"105","cpus":"2","cpu":0.25,"mem":512,"maxmem":1024,"swap":0,"maxswap":256,"disk":50,"maxdisk":100,"diskread":0,"netout":32,"uptime":12,"ip":"192.0.2.5","network":{"eth0":{"name":"eth0","ip":"192.0.2.5/24"}},"diskinfo":{"rootfs":{"total":100,"used":50}}}}`)+ }))+ defer server.Close()+ got, err := backupTestClient(t, server.URL).GetContainerStatus(context.Background(), "member", 105)+ if err != nil {+ t.Fatal(err)+ }+ if got.VMID != 105 || got.CPUs != 2 || got.CPU != .25 || got.Mem != 512 || got.MaxMem != 1024 || got.MaxSwap != 256 || got.Disk != 50 || got.MaxDisk != 100 || got.NetOut != 32 || got.Uptime != 12 || got.IP != "192.0.2.5" || len(got.Network) != 1 || got.DiskInfo["rootfs"].Used != 50 {+ t.Fatalf("LXC fields changed: %+v", got)+ }+ if got.IOCounters != (IOCounterPresence{Explicit: true, DiskRead: true, NetworkOut: true}) {+ t.Fatalf("missing/zero counter semantics changed: %+v", got.IOCounters)+ }+ })+}++type guestStatusCloseFailure struct {+ io.Reader+ closed bool+}++func (b *guestStatusCloseFailure) Close() error {+ b.closed = true+ return errors.New("fixture close failed")+}++func TestGuestStatusRequiresCompletedResponse(t *testing.T) {+ for _, kind := range []string{"qemu", "lxc"} {+ for _, code := range []int{http.StatusNoContent, http.StatusPartialContent} {+ resp := &http.Response{StatusCode: code, Body: io.NopCloser(strings.NewReader(`{"data":{"status":"running"}}`))}+ var err error+ if kind == "qemu" {+ _, err = readGuestStatus[VMStatus](resp, 105)+ } else {+ _, err = readGuestStatus[Container](resp, 105)+ }+ if err == nil {+ t.Errorf("status %d established %s observation", code, kind)+ }+ }+ body := &guestStatusCloseFailure{Reader: strings.NewReader(`{"data":{"status":"running"}}`)}+ resp := &http.Response{StatusCode: http.StatusOK, Body: body}+ var err error+ if kind == "qemu" {+ _, err = readGuestStatus[VMStatus](resp, 105)+ } else {+ _, err = readGuestStatus[Container](resp, 105)+ }+ if err == nil || !body.closed {+ t.Errorf("close failure established %s observation: closed=%t err=%v", kind, body.closed, err)+ }+ }+}