public async Task UpdateReadEventSystemStateAsync(EventSystemState state)
{
using (var conn = connectionFactory.GetEddsPerformanceConnection())
{
await conn.ExecuteAsync(Resources.Event_UpdateEventSystemState, new { state });
}
}
public void DatabaseDeploymentFailureAlert(EventStatus status, EventSystemState systemState, NotificationType?expctedType, bool expectedResult)
{
this.serverRepository.Setup(r => r.ReadAllActiveAsync())
.ReturnsAsync(new[] { new Server {
ServerId = 1234, ServerType = ServerType.Database
} });
this.eventRepository.Setup(r => r.ReadLastBySourceIdAndTypeAsync(EventSourceType.DeployServerDatabases, 1234))
.ReturnsAsync(new Event {
Status = status
});
this.eventRepository.Setup(r => r.ReadEventSystemStateAsync())
.ReturnsAsync(systemState);
//Act
var result = this.pdbNotificationService.GetDatabaseDeploymentFailureAlert();
//Assert
Assert.That(result != null, Is.EqualTo(expectedResult));
Assert.That(result?.Type, Is.EqualTo(expctedType));
}
public void Update()
{
mTimer -= GameState.GameDeltaTime;
switch (mState)
{
case EventSystemState.PENDING:
if (mTimer <= 0)
{
float warningTime = mEvent.Warn();
if (warningTime > 0)
{
mState = EventSystemState.WARNING;
mTimer = warningTime;
}
else
{
mState = EventSystemState.ACTIVE;
mTimer = mEvent.Start();
}
}
break;
case EventSystemState.WARNING:
if (mTimer <= 0)
{
mState = EventSystemState.ACTIVE;
mTimer = mEvent.Start();
}
break;
case EventSystemState.ACTIVE:
if (mEvent.Update() || mTimer <= 0)
{
mState = EventSystemState.COOLDOWN;
}
break;
}
}
public TimedEvent(RandomEvent ev, float timer)
{
mEvent = ev;
mTimer = timer;
mState = EventSystemState.PENDING;
}
public async Task GetBackfillStatus(string logEntryTaskCompleted, DateTime?lastEventLastUpdated, int pendingEvents, int erroredEvents, EventSystemState systemState, DateTime?minSampleDate, DateTime?maxSampleDate, int hoursAwaitingAnalysis, int hoursAwaitingDiscovery, int hoursAwaitingScoring, int hoursCompleted)
{
// Arrange
var logEntryResult = logEntryTaskCompleted == null ? null : new LogEntry {
TaskCompleted = logEntryTaskCompleted
};
this.sqlServerRepositoryMock.Setup(m => m.LogRepository.ReadLastAsync()).ReturnsAsync(logEntryResult);
var lastEventResult = lastEventLastUpdated == null ? null : new Event {
LastUpdated = lastEventLastUpdated.Value
};
this.sqlServerRepositoryMock.Setup(m => m.EventRepository.ReadLastAsync()).ReturnsAsync(lastEventResult);
this.sqlServerRepositoryMock.Setup(m => m.EventRepository.ReadCountByStatusAsync(It.Is <IList <EventStatus> >(val =>
val.Contains(EventStatus.Pending) && val.Contains(EventStatus.PendingHangfire) && val.Count == 2)))
.ReturnsAsync(pendingEvents);
this.sqlServerRepositoryMock
.Setup(m => m.EventRepository.ReadCountByStatusAsync(It.Is <EventStatus>(val => val == EventStatus.Error)))
.ReturnsAsync(erroredEvents);
this.sqlServerRepositoryMock.Setup(m => m.EventRepository.ReadEventSystemStateAsync()).ReturnsAsync(systemState);
this.sqlServerRepositoryMock.Setup(m => m.SampleHistoryRepository.ReadSampleRange())
.Returns(new SampleHistoryRange()
{
MaxSampleDate = maxSampleDate, MinSampleDate = minSampleDate
});
this.sqlServerRepositoryMock.Setup(m => m.BackfillRepository.ReadHoursAwaitingAnalysis())
.ReturnsAsync(hoursAwaitingAnalysis);
this.sqlServerRepositoryMock.Setup(m => m.BackfillRepository.ReadHoursAwaitingDiscovery())
.ReturnsAsync(hoursAwaitingDiscovery);
this.sqlServerRepositoryMock.Setup(m => m.BackfillRepository.ReadHoursAwaitingScoring())
.ReturnsAsync(hoursAwaitingScoring);
this.sqlServerRepositoryMock.Setup(m => m.BackfillRepository.ReadHoursCompletedScoring())
.ReturnsAsync(hoursCompleted);
// Act
var result = await this.backfillController.GetBackfillStatus();
// Assert
Assert.That(result, Is.Not.Null);
}
