public async Task ShouldThrowDependencyExceptionOnDeleteWhenDbUpdateConcurrencyExceptionOccursAndLogItAsync()
{
// given
Guid randomExamId = Guid.NewGuid();
Guid inputExamId = randomExamId;
var databaseUpdateConcurrencyException = new DbUpdateConcurrencyException();
var lockedExamException = new LockedExamException(databaseUpdateConcurrencyException);
var expectedExamDependencyException =
new ExamDependencyException(lockedExamException);
this.storageBrokerMock.Setup(broker =>
broker.SelectExamByIdAsync(inputExamId))
.ThrowsAsync(databaseUpdateConcurrencyException);
// when
ValueTask <Exam> deleteExamTask =
this.examService.RemoveExamByIdAsync(inputExamId);
// then
await Assert.ThrowsAsync <ExamDependencyException>(() =>
deleteExamTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedExamDependencyException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectExamByIdAsync(inputExamId),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
private async ValueTask <Exam> TryCatch(ReturningExamFunction returningExamFunction)
{
try
{
return(await returningExamFunction());
}
catch (NullExamException nullExamException)
{
throw CreateAndLogValidationException(nullExamException);
}
catch (InvalidExamException invalidExamInputException)
{
throw CreateAndLogValidationException(invalidExamInputException);
}
catch (NotFoundExamException nullExamException)
{
throw CreateAndLogValidationException(nullExamException);
}
catch (SqlException sqlException)
{
var failedExamStorageException =
new FailedExamStorageException(sqlException);
throw CreateAndLogCriticalDependencyException(failedExamStorageException);
}
catch (DuplicateKeyException duplicateKeyException)
{
var alreadyExistsExamException =
new AlreadyExistsExamException(duplicateKeyException);
throw CreateAndLogDependencyValidationException(alreadyExistsExamException);
}
catch (DbUpdateConcurrencyException dbUpdateConcurrencyException)
{
var lockedExamException = new LockedExamException(dbUpdateConcurrencyException);
throw CreateAndLogDependencyValidationException(lockedExamException);
}
catch (DbUpdateException dbUpdateException)
{
var failedExamStorageException =
new FailedExamStorageException(dbUpdateException);
throw CreateAndLogDependencyException(failedExamStorageException);
}
catch (Exception exception)
{
var failedExamServiceException =
new FailedExamServiceException(exception);
throw CreateAndLogServiceException(failedExamServiceException);
}
}
public async Task ShouldThrowDependencyValidationExceptionOnModifyIfDbUpdateConcurrencyErrorOccursAndLogItAsync()
{
// given
Exam someExam = CreateRandomExam();
var databaseUpdateConcurrencyException =
new DbUpdateConcurrencyException();
var lockedExamException =
new LockedExamException(databaseUpdateConcurrencyException);
var expectedExamDependencyValidationException =
new ExamDependencyValidationException(lockedExamException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Throws(databaseUpdateConcurrencyException);
// when
ValueTask <Exam> modifyExamTask =
this.examService.ModifyExamAsync(someExam);
// then
await Assert.ThrowsAsync <ExamDependencyValidationException>(() =>
modifyExamTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedExamDependencyValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectExamByIdAsync(someExam.Id),
Times.Never);
this.storageBrokerMock.Verify(broker =>
broker.UpdateExamAsync(someExam),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowDependencyExceptionOnModifyIfDbUpdateConcurrencyExceptionOccursAndLogItAsync()
{
// given
int randomNegativeNumber = GetNegativeRandomNumber();
DateTimeOffset randomDateTime = GetRandomDateTime();
Exam randomExam = CreateRandomExam(randomDateTime);
Exam someExam = randomExam;
someExam.CreatedDate = randomDateTime.AddMinutes(randomNegativeNumber);
var databaseUpdateConcurrencyException = new DbUpdateConcurrencyException();
var lockedExamException = new LockedExamException(databaseUpdateConcurrencyException);
var expectedExamDependencyException =
new ExamDependencyException(lockedExamException);
this.storageBrokerMock.Setup(broker =>
broker.SelectExamByIdAsync(someExam.Id))
.ThrowsAsync(databaseUpdateConcurrencyException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(randomDateTime);
// when
ValueTask <Exam> modifyExamTask =
this.examService.ModifyExamAsync(someExam);
// then
await Assert.ThrowsAsync <ExamDependencyException>(() =>
modifyExamTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectExamByIdAsync(someExam.Id),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedExamDependencyException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
