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.

21.7 KB
Raw Blame
package websocket

import (
	"bytes"
	"encoding/json"
	"fmt"
	"reflect"
	"strings"
	"testing"

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

// Keep the previous per-entry decoder as an independent compatibility oracle.
// This includes encoding/json's escaped, case-insensitive and duplicate-key
// handling instead of assuming the first JSON field is the authoritative ID.
func extractKeyedEntriesIndividually(encoded json.RawMessage, field string) (map[string]json.RawMessage, []string, error) {
	var entries []json.RawMessage
	if err := json.Unmarshal(encoded, &entries); err != nil {
		return nil, nil, err
	}
	byID := make(map[string]json.RawMessage)
	order := make([]string, 0, len(entries))
	for _, entry := range entries {
		var identity struct {
			ID string `json:"id"`
		}
		if err := json.Unmarshal(entry, &identity); err != nil {
			return nil, nil, err
		}
		if identity.ID == "" {
			return nil, nil, fmt.Errorf("state %s entry is missing id", field)
		}
		if _, exists := byID[identity.ID]; exists {
			return nil, nil, fmt.Errorf("state %s id %q is duplicated", field, identity.ID)
		}
		byID[identity.ID] = append(json.RawMessage(nil), entry...)
		order = append(order, identity.ID)
	}
	return byID, order, nil
}

func assertKeyedEntriesMatchPerEntryDecoding(t *testing.T, encoded []byte) {
	t.Helper()
	wantEntries, wantOrder, wantErr := extractKeyedEntriesIndividually(encoded, "resource")
	gotEntries, gotOrder, gotErr := extractKeyedEntries(encoded, "resource")
	if (wantErr == nil) != (gotErr == nil) {
		t.Fatalf("error changed: individual=%v batch=%v; JSON=%q", wantErr, gotErr, encoded)
	}
	if wantErr == nil && (!reflect.DeepEqual(gotEntries, wantEntries) || !reflect.DeepEqual(gotOrder, wantOrder)) {
		t.Fatalf("identity/order/payload changed: individual=%v/%v batch=%v/%v; JSON=%q", wantEntries, wantOrder, gotEntries, gotOrder, encoded)
	}
}

func FuzzExtractKeyedEntriesMatchesPerEntryDecoding(f *testing.F) {
	for _, encoded := range []string{
		`null`, `[]`, `[{"id":"r-1"},{"id":"r-2"}]`,
		`[{"name":"before-id","id":"尾\\\"\n\u0026","nested":{"id":"not-the-key"}}]`,
		`[{"id":"r-1"},{"id":"old","id":"r-3"}]`,
		`[{"ID":"case-insensitive"}]`, `[{"i\u0064":"escaped-key"}]`,
		`[{"id":"r-1"},{"id":"r-1"}]`, `[{"id":"r-1"},{}]`,
		`[null]`, `[{"id":null}]`, `[{"id":42}]`, `[42]`, `{}`, `[{`,
	} {
		f.Add([]byte(encoded))
	}
	f.Fuzz(assertKeyedEntriesMatchPerEntryDecoding)
}

func TestExtractKeyedEntriesOwnsEncodedBuffers(t *testing.T) {
	encoded := []byte(`[{"id":"r-1","name":"alpha"},{"id":"r-2","name":"beta"}]`)
	entries, order, err := extractKeyedEntries(encoded, "resource")
	if err != nil {
		t.Fatal(err)
	}
	if !reflect.DeepEqual(order, []string{"r-1", "r-2"}) {
		t.Fatalf("order = %v", order)
	}
	for i := range encoded {
		encoded[i] = 'x'
	}
	if !bytes.Equal(entries["r-1"], []byte(`{"id":"r-1","name":"alpha"}`)) ||
		!bytes.Equal(entries["r-2"], []byte(`{"id":"r-2","name":"beta"}`)) {
		t.Fatal("retained entries alias the original encoded buffer")
	}
	entries["r-1"][0] = 'x'
	if entries["r-2"][0] != '{' {
		t.Fatal("separate keyed entries alias each other")
	}
}

// A custom marshaler may preserve the first ID while replacing/reordering the
// tail. The encoded IDs, not a sampled check of source IDs, own delta identity.
type encodedStateFixture struct{ encoded json.RawMessage }

func (s encodedStateFixture) MarshalJSON() ([]byte, error) { return s.encoded, nil }

func TestSnapshotDeltaUsesEveryEncodedTailIdentity(t *testing.T) {
	previous, err := buildClientStateSnapshot(encodedStateFixture{json.RawMessage(`{
		"resources":[{"id":"r-1"},{"id":"r-2"}],
		"connectedInfrastructure":[{"id":"i-1"},{"id":"i-2"}],
		"activeAlerts":[{"id":"a-1"},{"id":"a-2"}]
	}`)})
	if err != nil {
		t.Fatal(err)
	}
	current, err := buildClientStateSnapshot(encodedStateFixture{json.RawMessage(`{
		"resources":[{"id":"r-1"},{"id":"r-3"}],
		"connectedInfrastructure":[{"id":"i-1"},{"id":"i-3"}],
		"activeAlerts":[{"id":"a-1"},{"id":"a-3"}]
	}`)})
	if err != nil {
		t.Fatal(err)
	}
	delta, err := buildClientStateDelta(previous, current)
	if err != nil {
		t.Fatal(err)
	}
	for field, prefix := range map[string]string{
		resourceDeltaField: "r", infrastructureDeltaField: "i", activeAlertsDeltaField: "a",
	} {
		payload, ok := delta[field].(resourceDeltaPayload)
		if !ok || !reflect.DeepEqual(payload.Removed, []string{prefix + "-2"}) ||
			!reflect.DeepEqual(payload.Order, []string{prefix + "-1", prefix + "-3"}) ||
			len(payload.Upserts) != 1 || string(payload.Upserts[0]) != `{"id":"`+prefix+`-3"}` {
			t.Fatalf("%s: wrong encoded tail identity: %#v", field, delta[field])
		}
	}
}

func TestFrontendSnapshotValuePointerAndGenericEncodingAgree(t *testing.T) {
	state := benchmarkFrontendState(100)
	state.Resources[99].ID = "尾<&\"\\\n"
	state.ConnectedInfrastructure = []models.ConnectedInfrastructureItemFrontend{{ID: "i-1"}, {ID: "i-2"}}
	state.ActiveAlerts = []models.Alert{{ID: "a-1"}, {ID: "a-2"}}
	encoded, err := json.Marshal(state)
	if err != nil {
		t.Fatal(err)
	}
	want, err := buildClientStateSnapshot(encodedStateFixture{encoded})
	if err != nil {
		t.Fatal(err)
	}
	for _, value := range []interface{}{state, &state} {
		got, err := buildClientStateSnapshot(value)
		if err != nil || !reflect.DeepEqual(got, want) {
			t.Fatalf("%T snapshot differs from its encoding: %v", value, err)
		}
	}
}

func TestClientStateDeltaOmitsUnchangedResourcePayload(t *testing.T) {
	previousState := models.EmptyStateFrontend()
	previousState.LastUpdate = 100
	previousState.Resources = []models.ResourceFrontend{{
		ID:           "agent:host-1",
		Type:         "agent",
		Name:         "host-1",
		DisplayName:  "host-1",
		Status:       "online",
		LastSeen:     100,
		CPU:          &models.ResourceMetricFrontend{Current: 40},
		PlatformData: json.RawMessage(`{"static":"` + strings.Repeat("x", 16*1024) + `"}`),
	}}
	currentState := previousState
	currentState.LastUpdate = 200
	currentState.Resources = append([]models.ResourceFrontend(nil), previousState.Resources...)
	currentState.Resources[0].LastSeen = 200
	currentState.Resources[0].CPU = &models.ResourceMetricFrontend{Current: 41}

	previous, err := buildClientStateSnapshot(previousState)
	if err != nil {
		t.Fatal(err)
	}
	current, err := buildClientStateSnapshot(currentState)
	if err != nil {
		t.Fatal(err)
	}
	delta, err := buildClientStateDelta(previous, current)
	if err != nil {
		t.Fatal(err)
	}
	encoded, err := json.Marshal(delta)
	if err != nil {
		t.Fatal(err)
	}
	if strings.Contains(string(encoded), strings.Repeat("x", 128)) {
		t.Fatal("state delta repeated unchanged platform data")
	}
	if !strings.Contains(string(encoded), `"current":41`) || !strings.Contains(string(encoded), `"lastSeen":200`) {
		t.Fatalf("state delta omitted changed telemetry: %s", encoded)
	}
	if len(encoded) >= 1024 {
		t.Fatalf("state delta = %d bytes, want a bounded telemetry patch", len(encoded))
	}
}

func TestClientStateDeltaTracksResourceRemovalAndOrder(t *testing.T) {
	previousState := models.EmptyStateFrontend()
	previousState.Resources = []models.ResourceFrontend{
		{ID: "a", Type: "agent", Name: "a", DisplayName: "a"},
		{ID: "b", Type: "agent", Name: "b", DisplayName: "b"},
	}
	currentState := models.EmptyStateFrontend()
	currentState.Resources = []models.ResourceFrontend{
		{ID: "c", Type: "agent", Name: "c", DisplayName: "c"},
		{ID: "a", Type: "agent", Name: "a", DisplayName: "a"},
	}

	previous, err := buildClientStateSnapshot(previousState)
	if err != nil {
		t.Fatal(err)
	}
	current, err := buildClientStateSnapshot(currentState)
	if err != nil {
		t.Fatal(err)
	}
	delta, err := buildClientStateDelta(previous, current)
	if err != nil {
		t.Fatal(err)
	}
	resources, ok := delta[resourceDeltaField].(resourceDeltaPayload)
	if !ok {
		t.Fatalf("resource delta type = %T", delta[resourceDeltaField])
	}
	if len(resources.Removed) != 1 || resources.Removed[0] != "b" {
		t.Fatalf("removed = %#v, want [b]", resources.Removed)
	}
	if len(resources.Order) != 2 || resources.Order[0] != "c" || resources.Order[1] != "a" {
		t.Fatalf("order = %#v, want [c a]", resources.Order)
	}
	if len(resources.Upserts) != 1 || !strings.Contains(string(resources.Upserts[0]), `"id":"c"`) {
		t.Fatalf("upserts = %s, want full resource c", resources.Upserts)
	}
}

func TestClientStateDeltaShipsInfrastructureAsKeyedPatches(t *testing.T) {
	previousState := models.EmptyStateFrontend()
	previousState.ConnectedInfrastructure = []models.ConnectedInfrastructureItemFrontend{
		{
			ID: "infra-1", Name: "host-1", Status: "online", LastSeen: 100,
			Surfaces: []models.ConnectedInfrastructureSurfaceFrontend{{
				ID: "surface-1", Kind: "agent", Label: strings.Repeat("s", 8*1024),
			}},
		},
		{ID: "infra-2", Name: "host-2", Status: "online", LastSeen: 100},
	}
	currentState := previousState
	currentState.ConnectedInfrastructure = append(
		[]models.ConnectedInfrastructureItemFrontend(nil),
		previousState.ConnectedInfrastructure...,
	)
	currentState.ConnectedInfrastructure[0].LastSeen = 200

	previous, err := buildClientStateSnapshot(previousState)
	if err != nil {
		t.Fatal(err)
	}
	current, err := buildClientStateSnapshot(currentState)
	if err != nil {
		t.Fatal(err)
	}
	delta, err := buildClientStateDelta(previous, current)
	if err != nil {
		t.Fatal(err)
	}
	if _, ok := delta[infrastructureField]; ok {
		t.Fatal("state delta re-shipped the full connectedInfrastructure projection")
	}
	payload, ok := delta[infrastructureDeltaField].(resourceDeltaPayload)
	if !ok {
		t.Fatalf("infrastructure delta type = %T", delta[infrastructureDeltaField])
	}
	if len(payload.Upserts) != 1 {
		t.Fatalf("upserts = %d, want 1", len(payload.Upserts))
	}
	patch := string(payload.Upserts[0])
	if !strings.Contains(patch, `"id":"infra-1"`) || !strings.Contains(patch, `"lastSeen":200`) {
		t.Fatalf("patch = %s, want id + lastSeen", patch)
	}
	if strings.Contains(patch, strings.Repeat("s", 128)) {
		t.Fatal("patch re-shipped the unchanged surfaces payload")
	}
	if len(patch) >= 256 {
		t.Fatalf("patch = %d bytes, want a bounded timestamp patch", len(patch))
	}
}

func TestClientStateDeltaTracksInfrastructureRemovalAndOrder(t *testing.T) {
	previousState := models.EmptyStateFrontend()
	previousState.ConnectedInfrastructure = []models.ConnectedInfrastructureItemFrontend{
		{ID: "a", Name: "a", Status: "online"},
		{ID: "b", Name: "b", Status: "online"},
	}
	currentState := models.EmptyStateFrontend()
	currentState.ConnectedInfrastructure = []models.ConnectedInfrastructureItemFrontend{
		{ID: "c", Name: "c", Status: "online"},
		{ID: "a", Name: "a", Status: "online"},
	}

	previous, err := buildClientStateSnapshot(previousState)
	if err != nil {
		t.Fatal(err)
	}
	current, err := buildClientStateSnapshot(currentState)
	if err != nil {
		t.Fatal(err)
	}
	delta, err := buildClientStateDelta(previous, current)
	if err != nil {
		t.Fatal(err)
	}
	payload, ok := delta[infrastructureDeltaField].(resourceDeltaPayload)
	if !ok {
		t.Fatalf("infrastructure delta type = %T", delta[infrastructureDeltaField])
	}
	if len(payload.Removed) != 1 || payload.Removed[0] != "b" {
		t.Fatalf("removed = %#v, want [b]", payload.Removed)
	}
	if len(payload.Order) != 2 || payload.Order[0] != "c" || payload.Order[1] != "a" {
		t.Fatalf("order = %#v, want [c a]", payload.Order)
	}
	if len(payload.Upserts) != 1 || !strings.Contains(string(payload.Upserts[0]), `"id":"c"`) {
		t.Fatalf("upserts = %s, want full item c", payload.Upserts)
	}
}

func TestClientStateDeltaFallsBackToFullInfrastructureWhenUnkeyed(t *testing.T) {
	// An entry without an id cannot key: the projection must fall back to the
	// plain whole-field diff instead of corrupting the keyed path.
	previousState := models.EmptyStateFrontend()
	previousState.ConnectedInfrastructure = []models.ConnectedInfrastructureItemFrontend{
		{Name: "anonymous", Status: "online"},
	}
	currentState := models.EmptyStateFrontend()
	currentState.ConnectedInfrastructure = []models.ConnectedInfrastructureItemFrontend{
		{Name: "anonymous", Status: "offline"},
	}

	previous, err := buildClientStateSnapshot(previousState)
	if err != nil {
		t.Fatal(err)
	}
	if previous.keyed[infrastructureField] != nil {
		t.Fatal("id-less projection must not key")
	}
	current, err := buildClientStateSnapshot(currentState)
	if err != nil {
		t.Fatal(err)
	}
	delta, err := buildClientStateDelta(previous, current)
	if err != nil {
		t.Fatal(err)
	}
	if _, ok := delta[infrastructureDeltaField]; ok {
		t.Fatal("unkeyed projection produced a keyed delta")
	}
	full, ok := delta[infrastructureField].(json.RawMessage)
	if !ok || !strings.Contains(string(full), `"offline"`) {
		t.Fatalf("full field = %v, want whole projection", delta[infrastructureField])
	}
}

func TestClientStateDeltaShipsFullInfrastructureWhenBaselineWasUnkeyed(t *testing.T) {
	previousState := models.EmptyStateFrontend()
	previousState.ConnectedInfrastructure = []models.ConnectedInfrastructureItemFrontend{
		{Name: "anonymous", Status: "online"},
	}
	currentState := models.EmptyStateFrontend()
	currentState.ConnectedInfrastructure = []models.ConnectedInfrastructureItemFrontend{
		{ID: "a", Name: "a", Status: "online"},
	}

	previous, err := buildClientStateSnapshot(previousState)
	if err != nil {
		t.Fatal(err)
	}
	current, err := buildClientStateSnapshot(currentState)
	if err != nil {
		t.Fatal(err)
	}
	delta, err := buildClientStateDelta(previous, current)
	if err != nil {
		t.Fatal(err)
	}
	if _, ok := delta[infrastructureDeltaField]; ok {
		t.Fatal("keyed delta emitted against an unkeyed baseline")
	}
	full, ok := delta[infrastructureField].(json.RawMessage)
	if !ok || !strings.Contains(string(full), `"id":"a"`) {
		t.Fatalf("full field = %v, want whole projection re-ship", delta[infrastructureField])
	}
}

func TestClientStateDeltaShipsActiveAlertsAsKeyedPatches(t *testing.T) {
	previousState := models.EmptyStateFrontend()
	previousState.ActiveAlerts = []models.Alert{
		{
			ID: "alert-1", Type: "cpu", Level: "warning", ResourceID: "vm-1",
			Message: strings.Repeat("m", 4*1024), Value: 85,
		},
		{ID: "alert-2", Type: "memory", Level: "warning", ResourceID: "vm-2", Value: 70},
	}
	currentState := previousState
	currentState.ActiveAlerts = append([]models.Alert(nil), previousState.ActiveAlerts...)
	currentState.ActiveAlerts[0].Level = "critical"
	currentState.ActiveAlerts[0].Value = 97

	previous, err := buildClientStateSnapshot(previousState)
	if err != nil {
		t.Fatal(err)
	}
	current, err := buildClientStateSnapshot(currentState)
	if err != nil {
		t.Fatal(err)
	}
	delta, err := buildClientStateDelta(previous, current)
	if err != nil {
		t.Fatal(err)
	}
	if _, ok := delta[activeAlertsField]; ok {
		t.Fatal("state delta re-shipped the full activeAlerts array")
	}
	payload, ok := delta[activeAlertsDeltaField].(resourceDeltaPayload)
	if !ok {
		t.Fatalf("alerts delta type = %T", delta[activeAlertsDeltaField])
	}
	if len(payload.Upserts) != 1 {
		t.Fatalf("upserts = %d, want 1", len(payload.Upserts))
	}
	patch := string(payload.Upserts[0])
	if !strings.Contains(patch, `"id":"alert-1"`) || !strings.Contains(patch, `"level":"critical"`) {
		t.Fatalf("patch = %s, want id + level", patch)
	}
	if strings.Contains(patch, strings.Repeat("m", 128)) {
		t.Fatal("patch re-shipped the unchanged alert message")
	}
	if len(patch) >= 256 {
		t.Fatalf("patch = %d bytes, want a bounded lifecycle patch", len(patch))
	}
}

func TestClientStateDeltaTracksResolvedAlertRemoval(t *testing.T) {
	previousState := models.EmptyStateFrontend()
	previousState.ActiveAlerts = []models.Alert{
		{ID: "alert-1", Type: "cpu", Level: "warning", ResourceID: "vm-1"},
		{ID: "alert-2", Type: "memory", Level: "warning", ResourceID: "vm-2"},
	}
	currentState := models.EmptyStateFrontend()
	currentState.ActiveAlerts = []models.Alert{
		{ID: "alert-2", Type: "memory", Level: "warning", ResourceID: "vm-2"},
	}

	previous, err := buildClientStateSnapshot(previousState)
	if err != nil {
		t.Fatal(err)
	}
	current, err := buildClientStateSnapshot(currentState)
	if err != nil {
		t.Fatal(err)
	}
	delta, err := buildClientStateDelta(previous, current)
	if err != nil {
		t.Fatal(err)
	}
	payload, ok := delta[activeAlertsDeltaField].(resourceDeltaPayload)
	if !ok {
		t.Fatalf("alerts delta type = %T", delta[activeAlertsDeltaField])
	}
	if len(payload.Removed) != 1 || payload.Removed[0] != "alert-1" {
		t.Fatalf("removed = %#v, want [alert-1]", payload.Removed)
	}
	if len(payload.Upserts) != 0 {
		t.Fatalf("upserts = %d, want none", len(payload.Upserts))
	}
}

func TestClientStateBaselineAdvancesOnlyAfterDeltaIsQueued(t *testing.T) {
	initial := models.EmptyStateFrontend()
	initial.LastUpdate = 100
	initial.Resources = []models.ResourceFrontend{{
		ID: "agent:host-1", Type: "agent", Name: "host-1", DisplayName: "host-1",
		CPU: &models.ResourceMetricFrontend{Current: 10},
	}}
	current := initial
	current.LastUpdate = 200
	current.Resources = append([]models.ResourceFrontend(nil), initial.Resources...)
	current.Resources[0].CPU = &models.ResourceMetricFrontend{Current: 20}

	client := &Client{send: make(chan []byte, 1)}
	if _, sent, err := client.queueFullState("initialState", initial); err != nil || !sent {
		t.Fatalf("queueFullState() sent=%v error=%v", sent, err)
	}
	initialBaseline := client.stateSnapshot
	currentSnapshot, err := buildClientStateSnapshot(current)
	if err != nil {
		t.Fatal(err)
	}

	if _, attempted, sent, err := client.queueStateDelta(currentSnapshot); err != nil || !attempted || sent {
		t.Fatalf("full-channel queueStateDelta() attempted=%v sent=%v error=%v", attempted, sent, err)
	}
	if client.stateSnapshot != initialBaseline {
		t.Fatal("client baseline advanced after the delta queue rejected the payload")
	}

	<-client.send
	if _, attempted, sent, err := client.queueStateDelta(currentSnapshot); err != nil || !attempted || !sent {
		t.Fatalf("retry queueStateDelta() attempted=%v sent=%v error=%v", attempted, sent, err)
	}
	if client.stateSnapshot != currentSnapshot {
		t.Fatal("client baseline did not advance after the delta was queued")
	}
}

// A receiver retains an unchanged breach date across held/recovery patches,
// advances it only with a new breach, and drops it when the producer has none.
func TestMetricBreachTimeStateDeltasPreserveAndWithdraw(t *testing.T) {
	state := models.EmptyStateFrontend()
	state.ActiveAlerts = []models.Alert{{ID: "alert-temperature", Type: "temperature", Value: 85}}
	setStatus := func(t *testing.T, body string) {
		t.Helper()
		state.ActiveAlerts[0].MetricStatus = nil
		if body != "" {
			var status models.MetricAlertStatus
			if err := json.Unmarshal([]byte(body), &status); err != nil {
				t.Fatal(err)
			}
			state.ActiveAlerts[0].MetricStatus = &status
		}
	}
	setStatus(t, `{"phase":"breaching","value":85,"trigger":80,"recovery":75,"observedAt":"2026-10-09T19:00:00Z","lastBreachAt":"2026-10-09T19:00:00Z"}`)
	previous, err := buildClientStateSnapshot(state)
	if err != nil {
		t.Fatal(err)
	}
	var received map[string]any
	if err := json.Unmarshal(previous.keyed[activeAlertsField].entries["alert-temperature"], &received); err != nil {
		t.Fatal(err)
	}
	checkDate := func(t *testing.T, want string) {
		t.Helper()
		status, _ := received["metricStatus"].(map[string]any)
		got, present := status["lastBreachAt"]
		if present != (want != "") || want != "" && got != want {
			t.Errorf("receiver date = %v present %v, want %q", got, present, want)
		}
		if _, present := received["lastSeen"]; present {
			t.Fatal("state dated lifecycle alerts through LastSeen")
		}
	}
	checkDate(t, "2026-10-09T19:00:00Z")
	for _, step := range []struct{ name, body, date string }{
		{"hold", `{"phase":"latched","value":78,"trigger":80,"recovery":75,"observedAt":"2026-10-09T19:01:00Z","lastBreachAt":"2026-10-09T19:00:00Z"}`, "2026-10-09T19:00:00Z"},
		{"recovery", `{"phase":"recovering","value":72,"trigger":80,"recovery":75,"observedAt":"2026-10-09T19:02:00Z","lastBreachAt":"2026-10-09T19:00:00Z","recoveryStartedAt":"2026-10-09T19:02:00Z"}`, "2026-10-09T19:00:00Z"},
		{"new breach", `{"phase":"breaching","value":90,"trigger":80,"recovery":75,"observedAt":"2026-10-09T19:03:00Z","lastBreachAt":"2026-10-09T19:03:00Z"}`, "2026-10-09T19:03:00Z"},
		{"unknown date", `{"phase":"latched","value":78,"trigger":80,"recovery":75,"observedAt":"2026-10-09T19:04:00Z"}`, ""},
		{"no live status", "", ""},
	} {
		t.Run(step.name, func(t *testing.T) {
			setStatus(t, step.body)
			current, err := buildClientStateSnapshot(state)
			if err != nil {
				t.Fatal(err)
			}
			delta, err := buildClientStateDelta(previous, current)
			if err != nil {
				t.Fatal(err)
			}
			payload, ok := delta[activeAlertsDeltaField].(resourceDeltaPayload)
			if !ok || len(payload.Upserts) != 1 || len(payload.Removed) != 0 {
				t.Fatalf("alert transition did not produce one keyed patch: %+v", delta)
			}
			if _, full := delta[activeAlertsField]; full {
				t.Fatal("transition re-shipped all active alerts")
			}
			var patch map[string]any
			if err := json.Unmarshal(payload.Upserts[0], &patch); err != nil {
				t.Fatal(err)
			}
			received = applyMetricBreachTimeMergePatch(received, patch)
			var complete map[string]any
			if err := json.Unmarshal(current.keyed[activeAlertsField].entries["alert-temperature"], &complete); err != nil {
				t.Fatal(err)
			}
			if !reflect.DeepEqual(received, complete) {
				t.Fatalf("receiver differs from complete state: %+v vs %+v", received, complete)
			}
			checkDate(t, step.date)
			previous = current
		})
	}
}

// Independent RFC 7396 receiver oracle for the alert's encoded keyed patch.
// Keep it with this control: helpers in the separate websocket_test package
// are not visible from package websocket.
func applyMetricBreachTimeMergePatch(previous, patch map[string]any) map[string]any {
	out := make(map[string]any, len(previous))
	for key, value := range previous {
		out[key] = value
	}
	for key, value := range patch {
		if value == nil {
			delete(out, key)
		} else if object, ok := value.(map[string]any); ok {
			old, _ := out[key].(map[string]any)
			out[key] = applyMetricBreachTimeMergePatch(old, object)
		} else {
			out[key] = value
		}
	}
	return out
}