adas-core/adas-core.Test/Services/AlarmServiceTest.cs

using System.Security.Claims;
using adas_core.Application.Repositories.Interfaces;
using adas_core.Application.Services;
using adas_core.Application.Services.Interfaces;
using adas_core.Domain.Enums;
using adas_core.Domain.Models;
using adas_core.Domain.Models.AppSettings;
using adas_core.Domain.Models.MongoModels;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using MongoDB.Bson;
using Moq;
using Options = Microsoft.Extensions.Options.Options;

namespace adas_core.Test.Services;

public class AlarmServiceTest
{
    private readonly Mock<IAlarmRepository> _alarmRepositoryMock;
    private readonly AlarmService _alarmService;


    private readonly ApiSettings _apiSettings = new()
    {
        ConfigObservation = new ConfigObservationSettings
        {
            IgnoreUnknownObservation = false
        },
        IntravenousLinesCode = ["10546003"],
        AllergiesCode = ["473011001"],
        DrainageCode = ["56868008"],
        IsolationCode = ["302147001"],
        PositionCode = ["386053000"]
    };

    private readonly Mock<ICalculatedObservationsService> _calculatedObservationsServiceMock;
    private readonly Mock<IConfigObservationService> _configObservationServiceMock;
    private readonly Mock<IObservationService> _observationServiceMock;
    private readonly Mock<IPatientService> _patientServiceMock;

    private readonly RecordingSettings _recordingSettings = new();
    private readonly Mock<IUnitService> _unitServiceMock;

    public AlarmServiceTest()
    {
        var optionsApiSettings = Options.Create(_apiSettings);
        Options.Create(_recordingSettings);

        _observationServiceMock = new Mock<IObservationService>();
        var observationServiceMockLazy = new Lazy<IObservationService>(() => _observationServiceMock.Object);

        _patientServiceMock = new Mock<IPatientService>();
        _configObservationServiceMock = new Mock<IConfigObservationService>();
        _unitServiceMock = new Mock<IUnitService>();
        var pocServiceMock = new Mock<IPointOfCareService>();

        var beaconServiceMock = new Mock<ILightBeaconService>();
        var beaconServiceMockLazy = new Lazy<ILightBeaconService>(() => beaconServiceMock.Object);

        var relayServiceMock = new Mock<IRelayService>();
        var relayServiceMockLazy = new Lazy<IRelayService>(() => relayServiceMock.Object);

        var recordingServiceMock = new Mock<IRecordingService>();
        var recordingServiceMockLazy = new Lazy<IRecordingService>(() => recordingServiceMock.Object);

        var clientMessageServiceMock = new Mock<IClientMessageService>();

        var subscribersServiceMock = new Mock<ISubscribersService>();

        var httpContextAccessorMock = new Mock<IHttpContextAccessor>();
        var auditServiceMock = new Mock<ILocalAuditService>();

        _calculatedObservationsServiceMock = new Mock<ICalculatedObservationsService>();
        var calculatedObservationsServiceLazy =
            new Lazy<ICalculatedObservationsService>(() => _calculatedObservationsServiceMock.Object);


        var logger = new Mock<ILogger<AlarmService>>();

        _alarmRepositoryMock = new Mock<IAlarmRepository>();
        var userClaims = new ClaimsPrincipal(new ClaimsIdentity([
            new Claim(ClaimTypes.Name, "TestUser")
        ], "mock"));

        var httpContextMock = new DefaultHttpContext
        {
            User = userClaims
        };

        httpContextAccessorMock.Setup(accessor => accessor.HttpContext)
            .Returns(httpContextMock);
        _alarmService = new AlarmService(
            _alarmRepositoryMock.Object,
            logger.Object,
            _patientServiceMock.Object,
            _configObservationServiceMock.Object,
            observationServiceMockLazy,
            clientMessageServiceMock.Object,
            subscribersServiceMock.Object,
            calculatedObservationsServiceLazy,
            beaconServiceMockLazy,
            recordingServiceMockLazy,
            relayServiceMockLazy,
            optionsApiSettings,
            _unitServiceMock.Object,
            pocServiceMock.Object,
            httpContextAccessorMock.Object,
            auditServiceMock.Object,
            false // Disable the timer for testing
        );
    }


    [Test]
    public async Task SaveRequest_Oru_R40_Type_Without_Alarms_Dont_Insert()
    {
        // Arrange
        var apiRequest = new ApiRequest
        {
            Type = "ORU_R40",
            PatientNumber = "12345",
            Observation = new PatientObservation { Value = "Test" },
            Alarms = [],
            Location = new PatientLocation { Bed = "Bed1", Room = "Bed1", UnitName = "Unit1" }
        };
        var unit = new Unit { Configuration = new UnitConfiguration { AutoAdt = true } };
        var patient = new Patient { Id = ObjectId.GenerateNewId(), Bed = "Bed1" };
        _unitServiceMock.Setup(u => u.FindByUnitNameOrPocName(It.IsAny<string>(), It.IsAny<string>()))
            .ReturnsAsync(unit);
        _patientServiceMock.Setup(p => p.FindPatientByApiRequest(apiRequest)).ReturnsAsync(patient);
        _observationServiceMock.Setup(o => o.SaveRequestAsync(It.IsAny<ApiRequest>())).Returns(Task.CompletedTask);

        // Act
        await _alarmService.SaveRequest(apiRequest);

        // Assert
        _patientServiceMock.Verify(p => p.FindPatientByApiRequest(apiRequest), Times.Once);
        _observationServiceMock.Verify(o => o.SaveRequestAsync(It.IsAny<ApiRequest>()), Times.Never);
    }

    [Test]
    public async Task ProcessAlarmObservations_Should_Insert_Alarm_Observations()
    {
        // Arrange
        var patient = new Patient { Id = ObjectId.GenerateNewId(), Bed = "Bed1" };
        var alarmObservations = new List<PatientObservationAlarm>
        {
            new() { Value = "Alarm1", Time = DateTime.UtcNow}
        };
        var observations = new List<PatientObservation>
        {
            new() { Value = "Alarm1", Time = DateTime.MinValue}
        };

        _configObservationServiceMock.Setup(o => o.Map(It.IsAny<PatientObservationAlarm>(), It.IsAny<bool>()))
            .ReturnsAsync((PatientObservationAlarm obs, bool _) => obs); // Correct setup

        _calculatedObservationsServiceMock.Setup(o => o.Map(It.IsAny<PatientObservationAlarm>(), It.IsAny<bool>()))
            .ReturnsAsync((PatientObservationAlarm obs, bool _) => obs); // Correct setup

        // Act
        await _alarmService.ProcessAlarmObservations(alarmObservations, observations, patient, DateTime.UtcNow);

        // Assert
        _alarmRepositoryMock.Verify(a => a.InsertOneAsync(It.IsAny<PatientObservationAlarm>()), Times.Once);
    }

    [Test]
    public async Task CheckObservationAlarm_Alarm_EventPEEP_PEEP_bajo_create_Event()
    {
        var obs = new PatientObservation();

        var configs = new ConfigObservation
        {
            Id = ObjectId.GenerateNewId(),
            Name = "Event_PEEP_Low",
            CodingSystem = "ADAS_EVENT",
            Description = "EVT_LO and EVT_EXTR_LO"
        };

        _configObservationServiceMock.Setup(c => c.Get(It.IsAny<PatientObservation>(), false))
            .ReturnsAsync(configs);

        await _alarmService.CheckObservationAlarm(obs);


        _observationServiceMock.Verify(o => o.InsertObservation(obs, true, true), Times.Never);
    }

    [Test]
    public async Task CheckObservationAlarm_Should_Launch_Red_Alarm_And_Set_BeaconColor_Red()
    {
        var alarmConfig = new AlarmConfig
        {
            Enabled = true,
            Priority = 10,
            Beacon = new AlarmItem
            {
                Enabled = true,
                BeaconColor = AlarmEnum.BeaconColor.Red, // Using the enum value
                EndAfter = 60 // Assuming the alarm should end after 60 seconds
            }
        };

        var configs = new ConfigObservation
        {
            Id = ObjectId.GenerateNewId(),
            Name = "Event_PEEP_Low",
            CodingSystem = "ADAS_EVENT",
            Description = "logs an event. No generate an alarm.",
            Alarm = alarmConfig,
            RequiredValue = "PEEP"
        };

        var obsConfig = new ConfigObservation
        {
            Id = ObjectId.GenerateNewId(),
            Name = "EVT_LO",
            CheckObservations = true,
            CreateObservation = [configs]
        };
        var patId = ObjectId.GenerateNewId();
        // Arrange
        var obs = new PatientObservation
        {
            Id = ObjectId.GenerateNewId(),
            Name = "EVT_LO",
            PatientId = patId,
            Value = "PEEP High",
            Time = DateTime.UtcNow,
            CheckObservations = true,
            CreateObservation = [configs]
        };

        _configObservationServiceMock.Setup(c => c.Get(It.IsAny<PatientObservation>(), false))
            .ReturnsAsync(obsConfig);


        // Act
        await _alarmService.CheckObservationAlarm(obs);

        _observationServiceMock.Verify(
            o => o.InsertObservation(
                It.Is<PatientObservation>(ob => ob.Value.ToString() == "PEEP High"), true, true),
            Times.Once);
    }
}