test: create test for concurrency
This commit is contained in:
voltsrage
@@ -0,0 +1,534 @@
|
||||
using System.Text.Json;
|
||||
using Confluent.Kafka;
|
||||
using FluentAssertions;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Microsoft.Extensions.Logging.Abstractions;
|
||||
using StackExchange.Redis;
|
||||
|
||||
[Collection("Integration")]
|
||||
public class BackgroundServiceTests : IAsyncLifetime
|
||||
{
|
||||
private readonly ApiFixture _fixture;
|
||||
|
||||
public BackgroundServiceTests(ApiFixture fixture) => _fixture = fixture;
|
||||
|
||||
public async Task InitializeAsync()
|
||||
{
|
||||
using var scope = _fixture.Services.CreateScope();
|
||||
var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
|
||||
await DbResetHelper.ResetAsync(db);
|
||||
|
||||
var redis = scope.ServiceProvider.GetRequiredService<IConnectionMultiplexer>();
|
||||
var server = redis.GetServer(redis.GetEndPoints().First());
|
||||
await server.FlushDatabaseAsync(1);
|
||||
}
|
||||
|
||||
public Task DisposeAsync() => Task.CompletedTask;
|
||||
|
||||
// =======================================================================
|
||||
// PoisonPillGuard — unit tests (no infrastructure needed)
|
||||
// =======================================================================
|
||||
|
||||
[Fact]
|
||||
public void PoisonPillGuard_PermanentError_SkipsImmediately()
|
||||
{
|
||||
var guard = new PoisonPillGuard("test-group", maxRetries: 5, NullLogger.Instance);
|
||||
var result = BuildConsumeResult("test-topic", 0, 0, "bad payload");
|
||||
|
||||
var shouldSkip = guard.ShouldSkip(result, new JsonException("Invalid JSON"));
|
||||
|
||||
shouldSkip.Should().BeTrue("permanent errors (JsonException) must be skipped immediately");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PoisonPillGuard_FormatException_SkipsImmediately()
|
||||
{
|
||||
var guard = new PoisonPillGuard("test-group", maxRetries: 5, NullLogger.Instance);
|
||||
var result = BuildConsumeResult("test-topic", 0, 0, "not-a-guid");
|
||||
|
||||
var shouldSkip = guard.ShouldSkip(result, new FormatException("Input string was not in a correct format"));
|
||||
|
||||
shouldSkip.Should().BeTrue("FormatException is a permanent error and must be skipped immediately");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PoisonPillGuard_WrappedPermanentError_SkipsImmediately()
|
||||
{
|
||||
var guard = new PoisonPillGuard("test-group", maxRetries: 5, NullLogger.Instance);
|
||||
var result = BuildConsumeResult("test-topic", 0, 0, "bad");
|
||||
|
||||
var wrappedException = new InvalidOperationException(
|
||||
"Processing failed", new JsonException("Invalid JSON"));
|
||||
|
||||
var shouldSkip = guard.ShouldSkip(result, wrappedException);
|
||||
|
||||
shouldSkip.Should().BeTrue(
|
||||
"permanent errors wrapped in other exceptions must still be detected via root cause");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PoisonPillGuard_TransientError_RetriesUpToMax()
|
||||
{
|
||||
const int maxRetries = 3;
|
||||
var guard = new PoisonPillGuard("test-group", maxRetries, NullLogger.Instance);
|
||||
var result = BuildConsumeResult("test-topic", 0, 42, "payload");
|
||||
var transientError = new TimeoutException("Connection timed out");
|
||||
|
||||
for (var i = 1; i < maxRetries; i++)
|
||||
{
|
||||
var shouldSkip = guard.ShouldSkip(result, transientError);
|
||||
shouldSkip.Should().BeFalse($"retry {i}/{maxRetries} should not skip");
|
||||
}
|
||||
|
||||
var finalSkip = guard.ShouldSkip(result, transientError);
|
||||
finalSkip.Should().BeTrue(
|
||||
$"after {maxRetries} retries, the message must be skipped");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PoisonPillGuard_SuccessResetsRetryCount()
|
||||
{
|
||||
const int maxRetries = 3;
|
||||
var guard = new PoisonPillGuard("test-group", maxRetries, NullLogger.Instance);
|
||||
var result = BuildConsumeResult("test-topic", 0, 42, "payload");
|
||||
var transientError = new TimeoutException("Connection timed out");
|
||||
|
||||
guard.ShouldSkip(result, transientError);
|
||||
guard.ShouldSkip(result, transientError);
|
||||
|
||||
guard.OnSuccess();
|
||||
|
||||
guard.ShouldSkip(result, transientError).Should().BeFalse(
|
||||
"after OnSuccess, retry count resets and first failure should not skip");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PoisonPillGuard_DifferentOffset_ResetsRetryCount()
|
||||
{
|
||||
const int maxRetries = 3;
|
||||
var guard = new PoisonPillGuard("test-group", maxRetries, NullLogger.Instance);
|
||||
var transientError = new TimeoutException("Connection timed out");
|
||||
|
||||
var result1 = BuildConsumeResult("test-topic", 0, 42, "payload-a");
|
||||
guard.ShouldSkip(result1, transientError);
|
||||
guard.ShouldSkip(result1, transientError);
|
||||
|
||||
var result2 = BuildConsumeResult("test-topic", 0, 43, "payload-b");
|
||||
guard.ShouldSkip(result2, transientError).Should().BeFalse(
|
||||
"a new offset resets the retry counter");
|
||||
}
|
||||
|
||||
// =======================================================================
|
||||
// Outbox relay — retry count and dead-letter behavior
|
||||
// =======================================================================
|
||||
|
||||
[Fact]
|
||||
public async Task OutboxEvent_UnprocessedEvents_ArePickedUpByRelay()
|
||||
{
|
||||
using var scope = _fixture.Services.CreateScope();
|
||||
var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
|
||||
|
||||
var encounterId = Guid.NewGuid();
|
||||
db.OutboxEvents.Add(new OutboxEvent
|
||||
{
|
||||
Id = Guid.NewGuid(),
|
||||
Topic = "observation.recorded",
|
||||
Payload = JsonSerializer.Serialize(new { encounterId, code = "HEART_RATE", value = 80 }),
|
||||
PartitionKey = encounterId.ToString(),
|
||||
CreatedAt = DateTimeOffset.UtcNow
|
||||
});
|
||||
await db.SaveChangesAsync();
|
||||
|
||||
var pendingBefore = await db.OutboxEvents
|
||||
.CountAsync(e => e.ProcessedAt == null && e.FailedAt == null);
|
||||
|
||||
pendingBefore.Should().BeGreaterThanOrEqualTo(1);
|
||||
|
||||
var deadline = DateTimeOffset.UtcNow.AddSeconds(15);
|
||||
while (DateTimeOffset.UtcNow < deadline)
|
||||
{
|
||||
await Task.Delay(500);
|
||||
var remaining = await db.OutboxEvents
|
||||
.AsNoTracking()
|
||||
.CountAsync(e => e.ProcessedAt == null && e.FailedAt == null);
|
||||
if (remaining == 0) break;
|
||||
}
|
||||
|
||||
var unprocessed = await db.OutboxEvents
|
||||
.AsNoTracking()
|
||||
.CountAsync(e => e.ProcessedAt == null && e.FailedAt == null);
|
||||
|
||||
unprocessed.Should().Be(0, "the outbox relay should process all pending events");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task OutboxEvent_FailedEvents_HaveRetryCountAndError()
|
||||
{
|
||||
using var scope = _fixture.Services.CreateScope();
|
||||
var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
|
||||
|
||||
var failedEvent = new OutboxEvent
|
||||
{
|
||||
Id = Guid.NewGuid(),
|
||||
Topic = "nonexistent.topic.that.will.fail",
|
||||
Payload = "{}",
|
||||
PartitionKey = "test",
|
||||
CreatedAt = DateTimeOffset.UtcNow,
|
||||
RetryCount = 9,
|
||||
LastError = "Simulated prior failure"
|
||||
};
|
||||
db.OutboxEvents.Add(failedEvent);
|
||||
await db.SaveChangesAsync();
|
||||
|
||||
failedEvent.RetryCount.Should().Be(9);
|
||||
failedEvent.LastError.Should().NotBeNullOrEmpty();
|
||||
failedEvent.ProcessedAt.Should().BeNull();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task OutboxEvent_FailedAtSet_EventIsNotReprocessed()
|
||||
{
|
||||
using var scope = _fixture.Services.CreateScope();
|
||||
var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
|
||||
|
||||
var deadLetteredEvent = new OutboxEvent
|
||||
{
|
||||
Id = Guid.NewGuid(),
|
||||
Topic = "test.topic",
|
||||
Payload = "{}",
|
||||
PartitionKey = "test",
|
||||
CreatedAt = DateTimeOffset.UtcNow,
|
||||
RetryCount = 10,
|
||||
LastError = "Exceeded max retries",
|
||||
FailedAt = DateTimeOffset.UtcNow.AddMinutes(-1)
|
||||
};
|
||||
db.OutboxEvents.Add(deadLetteredEvent);
|
||||
await db.SaveChangesAsync();
|
||||
|
||||
await Task.Delay(3_000);
|
||||
|
||||
var evt = await db.OutboxEvents
|
||||
.AsNoTracking()
|
||||
.SingleAsync(e => e.Id == deadLetteredEvent.Id);
|
||||
|
||||
evt.ProcessedAt.Should().BeNull("dead-lettered events must not be reprocessed");
|
||||
evt.FailedAt.Should().NotBeNull();
|
||||
}
|
||||
|
||||
// =======================================================================
|
||||
// SepsisBundleMonitor — concurrent scan safety
|
||||
// =======================================================================
|
||||
|
||||
[Fact]
|
||||
public async Task SepsisBundleMonitor_ConcurrentScans_NoDuplicateUpdates()
|
||||
{
|
||||
var (_, encounterId) = await SeedPatientEncounterAndBundleAsync();
|
||||
|
||||
using (var scope = _fixture.Services.CreateScope())
|
||||
{
|
||||
var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
|
||||
var bundle = await db.SepsisBundles.SingleAsync(b => b.EncounterId == encounterId);
|
||||
bundle.DeadlineAt = DateTimeOffset.UtcNow.AddHours(-1);
|
||||
await db.SaveChangesAsync();
|
||||
}
|
||||
|
||||
var tasks = Enumerable.Range(0, 5).Select(_ =>
|
||||
{
|
||||
return Task.Run(async () =>
|
||||
{
|
||||
var monitor = new SepsisBundleMonitorService(
|
||||
_fixture.Services,
|
||||
_fixture.Services.GetRequiredService<ClinicalMetrics>(),
|
||||
_fixture.Services.GetRequiredService<ILogger<SepsisBundleMonitorService>>());
|
||||
await monitor.ScanOverdueBundlesAsync(CancellationToken.None);
|
||||
});
|
||||
});
|
||||
|
||||
await Task.WhenAll(tasks);
|
||||
|
||||
using var verifyScope = _fixture.Services.CreateScope();
|
||||
var verifyDb = verifyScope.ServiceProvider.GetRequiredService<AppDbContext>();
|
||||
|
||||
var bundles = await verifyDb.SepsisBundles
|
||||
.AsNoTracking()
|
||||
.Where(b => b.EncounterId == encounterId)
|
||||
.ToListAsync();
|
||||
|
||||
bundles.Should().HaveCount(1);
|
||||
bundles[0].ComplianceStatus.Should().Be(SepsisBundleComplianceStatus.NonCompliant);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task SepsisBundleMonitor_CompletedBundle_NotMarkedOverdue()
|
||||
{
|
||||
var (_, encounterId) = await SeedPatientEncounterAndBundleAsync();
|
||||
|
||||
using (var scope = _fixture.Services.CreateScope())
|
||||
{
|
||||
var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
|
||||
var bundle = await db.SepsisBundles.SingleAsync(b => b.EncounterId == encounterId);
|
||||
bundle.ComplianceStatus = SepsisBundleComplianceStatus.Compliant;
|
||||
bundle.CompletedAt = DateTimeOffset.UtcNow;
|
||||
bundle.DeadlineAt = DateTimeOffset.UtcNow.AddHours(-1);
|
||||
await db.SaveChangesAsync();
|
||||
}
|
||||
|
||||
var monitor = new SepsisBundleMonitorService(
|
||||
_fixture.Services,
|
||||
_fixture.Services.GetRequiredService<ClinicalMetrics>(),
|
||||
_fixture.Services.GetRequiredService<ILogger<SepsisBundleMonitorService>>());
|
||||
|
||||
await monitor.ScanOverdueBundlesAsync(CancellationToken.None);
|
||||
|
||||
using var verifyScope = _fixture.Services.CreateScope();
|
||||
var verifyDb = verifyScope.ServiceProvider.GetRequiredService<AppDbContext>();
|
||||
|
||||
var bundle2 = await verifyDb.SepsisBundles
|
||||
.AsNoTracking()
|
||||
.SingleAsync(b => b.EncounterId == encounterId);
|
||||
|
||||
bundle2.ComplianceStatus.Should().Be(SepsisBundleComplianceStatus.Compliant,
|
||||
"already-completed bundles must not be marked non-compliant by the monitor");
|
||||
}
|
||||
|
||||
// =======================================================================
|
||||
// EscalationWorker — only escalates open alerts
|
||||
// =======================================================================
|
||||
|
||||
[Fact]
|
||||
public async Task EscalationWorker_AcknowledgedAlert_NotEscalated()
|
||||
{
|
||||
using var scope = _fixture.Services.CreateScope();
|
||||
var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
|
||||
|
||||
var (patientId, encounterId) = await SeedPatientAndEncounterAsync();
|
||||
|
||||
var alertId = Guid.NewGuid();
|
||||
db.ClinicalAlerts.Add(new ClinicalAlert
|
||||
{
|
||||
Id = alertId,
|
||||
EncounterId = encounterId,
|
||||
PatientId = patientId,
|
||||
AlertType = AlertType.SofaSepsis,
|
||||
Severity = AlertSeverity.Critical,
|
||||
Details = "SOFA delta +2",
|
||||
Status = AlertStatus.Acknowledged,
|
||||
TriggeredAt = DateTimeOffset.UtcNow
|
||||
});
|
||||
await db.SaveChangesAsync();
|
||||
|
||||
var escalationService = new EscalationWorkerService(
|
||||
_fixture.Services.GetRequiredService<Microsoft.Extensions.Options.IOptions<RabbitMqOptions>>(),
|
||||
_fixture.Services.GetRequiredService<IServiceScopeFactory>(),
|
||||
_fixture.Services.GetRequiredService<ClinicalMetrics>(),
|
||||
_fixture.Services.GetRequiredService<ILogger<EscalationWorkerService>>());
|
||||
|
||||
var escalated = await InvokeUpdateAlertStatusEscalatedAsync(escalationService, alertId);
|
||||
|
||||
escalated.Should().BeFalse("acknowledged alerts must not be escalated");
|
||||
|
||||
var alert = await db.ClinicalAlerts.AsNoTracking().SingleAsync(a => a.Id == alertId);
|
||||
alert.Status.Should().Be(AlertStatus.Acknowledged);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task EscalationWorker_ResolvedAlert_NotEscalated()
|
||||
{
|
||||
using var scope = _fixture.Services.CreateScope();
|
||||
var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
|
||||
|
||||
var (patientId, encounterId) = await SeedPatientAndEncounterAsync();
|
||||
|
||||
var alertId = Guid.NewGuid();
|
||||
db.ClinicalAlerts.Add(new ClinicalAlert
|
||||
{
|
||||
Id = alertId,
|
||||
EncounterId = encounterId,
|
||||
PatientId = patientId,
|
||||
AlertType = AlertType.SofaSepsis,
|
||||
Severity = AlertSeverity.Critical,
|
||||
Details = "SOFA delta +2",
|
||||
Status = AlertStatus.Resolved,
|
||||
TriggeredAt = DateTimeOffset.UtcNow
|
||||
});
|
||||
await db.SaveChangesAsync();
|
||||
|
||||
var escalationService = new EscalationWorkerService(
|
||||
_fixture.Services.GetRequiredService<Microsoft.Extensions.Options.IOptions<RabbitMqOptions>>(),
|
||||
_fixture.Services.GetRequiredService<IServiceScopeFactory>(),
|
||||
_fixture.Services.GetRequiredService<ClinicalMetrics>(),
|
||||
_fixture.Services.GetRequiredService<ILogger<EscalationWorkerService>>());
|
||||
|
||||
var escalated = await InvokeUpdateAlertStatusEscalatedAsync(escalationService, alertId);
|
||||
|
||||
escalated.Should().BeFalse("resolved alerts must not be escalated");
|
||||
|
||||
var alert = await db.ClinicalAlerts.AsNoTracking().SingleAsync(a => a.Id == alertId);
|
||||
alert.Status.Should().Be(AlertStatus.Resolved);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task EscalationWorker_OpenAlert_IsEscalated()
|
||||
{
|
||||
using var scope = _fixture.Services.CreateScope();
|
||||
var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
|
||||
|
||||
var (patientId, encounterId) = await SeedPatientAndEncounterAsync();
|
||||
|
||||
var alertId = Guid.NewGuid();
|
||||
db.ClinicalAlerts.Add(new ClinicalAlert
|
||||
{
|
||||
Id = alertId,
|
||||
EncounterId = encounterId,
|
||||
PatientId = patientId,
|
||||
AlertType = AlertType.SofaSepsis,
|
||||
Severity = AlertSeverity.Critical,
|
||||
Details = "SOFA delta +2",
|
||||
Status = AlertStatus.Open,
|
||||
TriggeredAt = DateTimeOffset.UtcNow
|
||||
});
|
||||
await db.SaveChangesAsync();
|
||||
|
||||
var escalationService = new EscalationWorkerService(
|
||||
_fixture.Services.GetRequiredService<Microsoft.Extensions.Options.IOptions<RabbitMqOptions>>(),
|
||||
_fixture.Services.GetRequiredService<IServiceScopeFactory>(),
|
||||
_fixture.Services.GetRequiredService<ClinicalMetrics>(),
|
||||
_fixture.Services.GetRequiredService<ILogger<EscalationWorkerService>>());
|
||||
|
||||
var escalated = await InvokeUpdateAlertStatusEscalatedAsync(escalationService, alertId);
|
||||
|
||||
escalated.Should().BeTrue("open alerts must be escalated");
|
||||
|
||||
var alert = await db.ClinicalAlerts.AsNoTracking().SingleAsync(a => a.Id == alertId);
|
||||
alert.Status.Should().Be(AlertStatus.Escalated);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task EscalationWorker_NonexistentAlert_ReturnsFalse()
|
||||
{
|
||||
var escalationService = new EscalationWorkerService(
|
||||
_fixture.Services.GetRequiredService<Microsoft.Extensions.Options.IOptions<RabbitMqOptions>>(),
|
||||
_fixture.Services.GetRequiredService<IServiceScopeFactory>(),
|
||||
_fixture.Services.GetRequiredService<ClinicalMetrics>(),
|
||||
_fixture.Services.GetRequiredService<ILogger<EscalationWorkerService>>());
|
||||
|
||||
var escalated = await InvokeUpdateAlertStatusEscalatedAsync(escalationService, Guid.NewGuid());
|
||||
|
||||
escalated.Should().BeFalse("nonexistent alerts must not cause errors");
|
||||
}
|
||||
|
||||
// =======================================================================
|
||||
// Cancellation — background services respect CancellationToken
|
||||
// =======================================================================
|
||||
|
||||
[Fact]
|
||||
public async Task SepsisBundleMonitor_CancellationRequested_StopsGracefully()
|
||||
{
|
||||
var monitor = new SepsisBundleMonitorService(
|
||||
_fixture.Services,
|
||||
_fixture.Services.GetRequiredService<ClinicalMetrics>(),
|
||||
_fixture.Services.GetRequiredService<ILogger<SepsisBundleMonitorService>>());
|
||||
|
||||
using var cts = new CancellationTokenSource();
|
||||
cts.Cancel();
|
||||
|
||||
var act = () => monitor.ScanOverdueBundlesAsync(cts.Token);
|
||||
|
||||
await act.Should().ThrowAsync<OperationCanceledException>();
|
||||
}
|
||||
|
||||
// =======================================================================
|
||||
// Helpers
|
||||
// =======================================================================
|
||||
|
||||
private static ConsumeResult<string, string> BuildConsumeResult(
|
||||
string topic, int partition, long offset, string value)
|
||||
{
|
||||
return new ConsumeResult<string, string>
|
||||
{
|
||||
Topic = topic,
|
||||
Partition = new Partition(partition),
|
||||
Offset = new Offset(offset),
|
||||
Message = new Message<string, string>
|
||||
{
|
||||
Key = "test-key",
|
||||
Value = value
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
private async Task<(Guid PatientId, Guid EncounterId)> SeedPatientAndEncounterAsync()
|
||||
{
|
||||
using var scope = _fixture.Services.CreateScope();
|
||||
var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
|
||||
|
||||
var patient = new Patient
|
||||
{
|
||||
Id = Guid.NewGuid(),
|
||||
Mrn = $"MRN-BG-{Guid.NewGuid():N}"[..20],
|
||||
FirstName = "Background",
|
||||
LastName = "Test",
|
||||
DateOfBirth = new DateOnly(1970, 1, 1),
|
||||
Gender = "M",
|
||||
CreatedAt = DateTimeOffset.UtcNow
|
||||
};
|
||||
var encounter = new Encounter
|
||||
{
|
||||
Id = Guid.NewGuid(),
|
||||
PatientId = patient.Id,
|
||||
EncounterType = EncounterType.Inpatient,
|
||||
Status = EncounterStatus.Active,
|
||||
Department = Department.Icu,
|
||||
AttendingPhysician = "Dr. Background",
|
||||
AdmittedAt = DateTimeOffset.UtcNow,
|
||||
CreatedAt = DateTimeOffset.UtcNow
|
||||
};
|
||||
|
||||
db.Patients.Add(patient);
|
||||
db.Encounters.Add(encounter);
|
||||
await db.SaveChangesAsync();
|
||||
|
||||
return (patient.Id, encounter.Id);
|
||||
}
|
||||
|
||||
private async Task<(Guid PatientId, Guid EncounterId)> SeedPatientEncounterAndBundleAsync()
|
||||
{
|
||||
var (patientId, encounterId) = await SeedPatientAndEncounterAsync();
|
||||
|
||||
using var scope = _fixture.Services.CreateScope();
|
||||
var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
|
||||
var handler = scope.ServiceProvider.GetRequiredService<SepsisAlertHandler>();
|
||||
|
||||
var alertId = Guid.NewGuid();
|
||||
db.ClinicalAlerts.Add(new ClinicalAlert
|
||||
{
|
||||
Id = alertId,
|
||||
EncounterId = encounterId,
|
||||
PatientId = patientId,
|
||||
AlertType = AlertType.SofaSepsis,
|
||||
Severity = AlertSeverity.Critical,
|
||||
Details = "SOFA delta +2",
|
||||
Status = AlertStatus.Open,
|
||||
TriggeredAt = DateTimeOffset.UtcNow
|
||||
});
|
||||
await db.SaveChangesAsync();
|
||||
|
||||
await handler.OnSepsisAlertCreatedAsync(
|
||||
encounterId, alertId, AlertType.SofaSepsis, CancellationToken.None);
|
||||
|
||||
return (patientId, encounterId);
|
||||
}
|
||||
|
||||
private static async Task<bool> InvokeUpdateAlertStatusEscalatedAsync(
|
||||
EscalationWorkerService service, Guid alertId)
|
||||
{
|
||||
var method = typeof(EscalationWorkerService).GetMethod(
|
||||
"UpdateAlertStatusEscalatedAsync",
|
||||
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
|
||||
|
||||
var task = (Task<bool>)method!.Invoke(service, new object[] { alertId, CancellationToken.None })!;
|
||||
return await task;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user