private ExamDependencyValidationException CreateAndLogDependencyValidationException(Xeption exception)
{
var examDependencyValidationException =
new ExamDependencyValidationException(exception);
this.loggingBroker.LogError(examDependencyValidationException);
return(examDependencyValidationException);
}
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 void ShouldThrowDependencyValidationExceptionOnAddIfExamAlreadyExistsAndLogItAsync()
{
// given
Exam someExam = CreateRandomExam();
string exceptionMessage = GetRandomMessage();
var duplicateKeyException =
new DuplicateKeyException(exceptionMessage);
var alreadyExistsExamException =
new AlreadyExistsExamException(duplicateKeyException);
var expectedExamDependencyValidationException =
new ExamDependencyValidationException(alreadyExistsExamException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Throws(duplicateKeyException);
// when
ValueTask <Exam> addExamTask =
this.examService.AddExamAsync(someExam);
// then
await Assert.ThrowsAsync <ExamDependencyValidationException>(() =>
addExamTask.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.InsertExamAsync(It.IsAny <Exam>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowDependencyValidationExceptionOnDeleteIfDbUpdateConcurrencyErrorOccursAndLogItAsync()
{
// given
Guid someExamId = Guid.NewGuid();
var databaseUpdateConcurrencyException =
new DbUpdateConcurrencyException();
var lockedExamException =
new LockedExamException(databaseUpdateConcurrencyException);
var expectedExamDependencyValidationException =
new ExamDependencyValidationException(lockedExamException);
this.storageBrokerMock.Setup(broker =>
broker.SelectExamByIdAsync(someExamId))
.ThrowsAsync(databaseUpdateConcurrencyException);
// when
ValueTask <Exam> deleteExamTask =
this.examService.RemoveExamByIdAsync(someExamId);
// then
await Assert.ThrowsAsync <ExamDependencyValidationException>(() =>
deleteExamTask.AsTask());
this.storageBrokerMock.Verify(broker =>
broker.SelectExamByIdAsync(someExamId),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedExamDependencyValidationException))),
Times.Once);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
