refactor(daemon): address monitoring layer nitpicks

- restore processExitSpy after each test to prevent spy leakage
- add Severity.MAJOR assertions to alert tests
- replace repeated choose+sendTo blocks with makeMonitoringSender factory

Author: andreabadesso

packages/daemon/__tests__/actors/MonitoringActor.test.ts

@@ -9,7 +9,7 @@ import MonitoringActor from '../../src/actors/MonitoringActor';
 import logger from '../../src/logger';
 import { EventTypes } from '../../src/types/event';
 import getConfig from '../../src/config';
-import { addAlert } from '@wallet-service/common';
+import { addAlert, Severity } from '@wallet-service/common';
 
 const MONITORING_IDLE_TIMEOUT_EVENT = { type: EventTypes.MONITORING_IDLE_TIMEOUT };
 
@@ -56,6 +56,10 @@ describe('MonitoringActor', () => {
     });
   });
 
+  afterEach(() => {
+    processExitSpy.mockRestore();
+  });
+
   afterAll(() => {
     jest.clearAllMocks();
     jest.useRealTimers();
@@ -98,6 +102,7 @@ describe('MonitoringActor', () => {
 
     expect(mockAddAlert).toHaveBeenCalledTimes(1);
     expect(mockAddAlert.mock.calls[0][0]).toBe('Daemon Idle — No Events Received');
+    expect(mockAddAlert.mock.calls[0][2]).toBe(Severity.MAJOR);
     expect(mockCallback).toHaveBeenCalledWith(MONITORING_IDLE_TIMEOUT_EVENT);
     expect(processExitSpy).not.toHaveBeenCalled();
   });
@@ -188,6 +193,7 @@ describe('MonitoringActor', () => {
 
     expect(mockAddAlert).toHaveBeenCalledTimes(1);
     expect(mockAddAlert.mock.calls[0][0]).toBe('Daemon Stuck In Processing State');
+    expect(mockAddAlert.mock.calls[0][2]).toBe(Severity.MAJOR);
     // Stuck detection intentionally does not notify the machine — machine keeps running
     expect(mockCallback).not.toHaveBeenCalled();
   });
@@ -243,6 +249,7 @@ describe('MonitoringActor', () => {
     await Promise.resolve();
     expect(mockAddAlert).toHaveBeenCalledTimes(1);
     expect(mockAddAlert.mock.calls[0][0]).toBe('Daemon Reconnection Storm');
+    expect(mockAddAlert.mock.calls[0][2]).toBe(Severity.MAJOR);
   });
 
   it('should NOT fire a reconnection storm alert below the threshold', async () => {

packages/daemon/src/actions/index.ts

@@ -6,7 +6,7 @@
  */
 
 import { assign, AssignAction, sendTo, choose } from 'xstate';
-import { Context, Event, EventTypes, StandardFullNodeEvent } from '../types';
+import { Context, Event, EventTypes, MonitoringEvent, StandardFullNodeEvent } from '../types';
 import { get } from 'lodash';
 import logger from '../logger';
 import { hashTxData } from '../utils';
@@ -211,53 +211,14 @@ export const getMonitoringRefFromContext = (context: Context) => {
 
 const monitoringIsPresent = (context: Context) => context.monitoring !== null;
 
-/*
- * Notifies the monitoring actor that the WebSocket became connected.
- */
-export const sendMonitoringConnected = choose([{
-  cond: monitoringIsPresent,
-  actions: sendTo(getMonitoringRefFromContext, { type: EventTypes.MONITORING_EVENT, event: { type: 'CONNECTED' } }),
-}]);
-
-/*
- * Notifies the monitoring actor that the WebSocket disconnected.
- */
-export const sendMonitoringDisconnected = choose([{
-  cond: monitoringIsPresent,
-  actions: sendTo(getMonitoringRefFromContext, { type: EventTypes.MONITORING_EVENT, event: { type: 'DISCONNECTED' } }),
-}]);
-
-/*
- * Notifies the monitoring actor that a fullnode event was received (resets the idle timer).
- */
-export const sendMonitoringEventReceived = choose([{
-  cond: monitoringIsPresent,
-  actions: sendTo(getMonitoringRefFromContext, { type: EventTypes.MONITORING_EVENT, event: { type: 'EVENT_RECEIVED' } }),
-}]);
-
-/*
- * Notifies the monitoring actor that the machine is entering the RECONNECTING state.
- */
-export const sendMonitoringReconnecting = choose([{
+const makeMonitoringSender = (eventType: MonitoringEvent['type']) => choose([{
   cond: monitoringIsPresent,
-  actions: sendTo(getMonitoringRefFromContext, { type: EventTypes.MONITORING_EVENT, event: { type: 'RECONNECTING' } }),
+  actions: sendTo(getMonitoringRefFromContext, { type: EventTypes.MONITORING_EVENT, event: { type: eventType } }),
 }]);
 
-/*
- * Notifies the monitoring actor that a processing state was entered.
- * The actor starts a stuck-detection timer; if PROCESSING_COMPLETED doesn't
- * arrive within STUCK_PROCESSING_TIMEOUT_MS it fires a MAJOR alert.
- */
-export const sendMonitoringProcessingStarted = choose([{
-  cond: monitoringIsPresent,
-  actions: sendTo(getMonitoringRefFromContext, { type: EventTypes.MONITORING_EVENT, event: { type: 'PROCESSING_STARTED' } }),
-}]);
-
-/*
- * Notifies the monitoring actor that a processing state was exited normally,
- * cancelling the stuck-detection timer.
- */
-export const sendMonitoringProcessingCompleted = choose([{
-  cond: monitoringIsPresent,
-  actions: sendTo(getMonitoringRefFromContext, { type: EventTypes.MONITORING_EVENT, event: { type: 'PROCESSING_COMPLETED' } }),
-}]);
+export const sendMonitoringConnected = makeMonitoringSender('CONNECTED');
+export const sendMonitoringDisconnected = makeMonitoringSender('DISCONNECTED');
+export const sendMonitoringEventReceived = makeMonitoringSender('EVENT_RECEIVED');
+export const sendMonitoringReconnecting = makeMonitoringSender('RECONNECTING');
+export const sendMonitoringProcessingStarted = makeMonitoringSender('PROCESSING_STARTED');
+export const sendMonitoringProcessingCompleted = makeMonitoringSender('PROCESSING_COMPLETED');