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
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
}