public async void ShouldThrowValidationExceptionOnAddWhenExamAttachmentIsNullAndLogItAsync()
{
// given
ExamAttachment invalidExamAttachment = null;
var nullExamAttachmentException = new NullExamAttachmentException();
var expectedExamAttachmentValidationException =
new ExamAttachmentValidationException(nullExamAttachmentException);
// when
ValueTask <ExamAttachment> addExamAttachmentTask =
this.examAttachmentService.AddExamAttachmentAsync(invalidExamAttachment);
// then
await Assert.ThrowsAsync <ExamAttachmentValidationException>(() =>
addExamAttachmentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedExamAttachmentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertExamAttachmentAsync(It.IsAny <ExamAttachment>()),
Times.Never);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenAttachmentIdIsInvalidAndLogItAsync()
{
// given
ExamAttachment randomExamAttachment = CreateRandomExamAttachment();
ExamAttachment inputExamAttachment = randomExamAttachment;
inputExamAttachment.AttachmentId = default;
var invalidExamAttachmentInputException = new InvalidExamAttachmentException(
parameterName: nameof(ExamAttachment.AttachmentId),
parameterValue: inputExamAttachment.AttachmentId);
var expectedExamAttachmentValidationException =
new ExamAttachmentValidationException(invalidExamAttachmentInputException);
// when
ValueTask <ExamAttachment> addExamAttachmentTask =
this.examAttachmentService.AddExamAttachmentAsync(inputExamAttachment);
// then
await Assert.ThrowsAsync <ExamAttachmentValidationException>(() =>
addExamAttachmentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedExamAttachmentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertExamAttachmentAsync(It.IsAny <ExamAttachment>()),
Times.Never);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
private ExamAttachmentValidationException CreateAndLogValidationException(Exception exception)
{
var ExamAttachmentValidationException = new ExamAttachmentValidationException(exception);
this.loggingBroker.LogError(ExamAttachmentValidationException);
return(ExamAttachmentValidationException);
}
public async Task ShouldThrowValidatonExceptionOnRemoveWhenIdsAreInvalidAndLogItAsync()
{
// given
Guid randomAttachmentId = default;
Guid randomExamId = default;
Guid inputAttachmentId = randomAttachmentId;
Guid inputExamId = randomExamId;
var invalidExamAttachmentInputException = new InvalidExamAttachmentException();
invalidExamAttachmentInputException.AddData(
key: nameof(ExamAttachment.ExamId),
values: "Id is required");
invalidExamAttachmentInputException.AddData(
key: nameof(ExamAttachment.AttachmentId),
values: "Id is required");
var expectedExamAttachmentValidationException =
new ExamAttachmentValidationException(invalidExamAttachmentInputException);
// when
ValueTask <ExamAttachment> removeExamAttachmentTask =
this.examAttachmentService.RemoveExamAttachmentByIdAsync(inputExamId, inputAttachmentId);
// then
await Assert.ThrowsAsync <ExamAttachmentValidationException>(() =>
removeExamAttachmentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameValidationExceptionAs(
expectedExamAttachmentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectExamAttachmentByIdAsync(It.IsAny <Guid>(), It.IsAny <Guid>()),
Times.Never);
this.storageBrokerMock.Verify(broker =>
broker.DeleteExamAttachmentAsync(It.IsAny <ExamAttachment>()),
Times.Never);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnRemoveWhenStorageExamAttachmentIsInvalidAndLogItAsync()
{
// given
DateTimeOffset randomDateTime = GetRandomDateTime();
ExamAttachment randomExamAttachment = CreateRandomExamAttachment(randomDateTime);
Guid inputAttachmentId = randomExamAttachment.AttachmentId;
Guid inputExamId = randomExamAttachment.ExamId;
ExamAttachment nullStorageExamAttachment = null;
var notFoundExamAttachmentException =
new NotFoundExamAttachmentException(inputExamId, inputAttachmentId);
var expectedExamValidationException =
new ExamAttachmentValidationException(notFoundExamAttachmentException);
this.storageBrokerMock.Setup(broker =>
broker.SelectExamAttachmentByIdAsync(inputExamId, inputAttachmentId))
.ReturnsAsync(nullStorageExamAttachment);
// when
ValueTask <ExamAttachment> removeExamAttachmentTask =
this.examAttachmentService.RemoveExamAttachmentByIdAsync(inputExamId, inputAttachmentId);
// then
await Assert.ThrowsAsync <ExamAttachmentValidationException>(() =>
removeExamAttachmentTask.AsTask());
this.storageBrokerMock.Verify(broker =>
broker.SelectExamAttachmentByIdAsync(It.IsAny <Guid>(), It.IsAny <Guid>()),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedExamValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.DeleteExamAttachmentAsync(It.IsAny <ExamAttachment>()),
Times.Never);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenExamAttachmentAlreadyExistsAndLogItAsync()
{
// given
ExamAttachment randomExamAttachment = CreateRandomExamAttachment();
ExamAttachment alreadyExistsExamAttachment = randomExamAttachment;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var duplicateKeyException = new DuplicateKeyException(exceptionMessage);
var alreadyExistsExamAttachmentException =
new AlreadyExistsExamAttachmentException(duplicateKeyException);
var expectedExamAttachmentValidationException =
new ExamAttachmentValidationException(alreadyExistsExamAttachmentException);
this.storageBrokerMock.Setup(broker =>
broker.InsertExamAttachmentAsync(alreadyExistsExamAttachment))
.ThrowsAsync(duplicateKeyException);
// when
ValueTask <ExamAttachment> addExamAttachmentTask =
this.examAttachmentService.AddExamAttachmentAsync(alreadyExistsExamAttachment);
// then
await Assert.ThrowsAsync <ExamAttachmentValidationException>(() =>
addExamAttachmentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedExamAttachmentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertExamAttachmentAsync(alreadyExistsExamAttachment),
Times.Once);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenReferneceExceptionAndLogItAsync()
{
// given
ExamAttachment randomExamAttachment = CreateRandomExamAttachment();
ExamAttachment invalidExamAttachment = randomExamAttachment;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var foreignKeyConstraintConflictException = new ForeignKeyConstraintConflictException(exceptionMessage);
var invalidExamAttachmentReferenceException =
new InvalidExamAttachmentReferenceException(foreignKeyConstraintConflictException);
var expectedExamAttachmentValidationException =
new ExamAttachmentValidationException(invalidExamAttachmentReferenceException);
this.storageBrokerMock.Setup(broker =>
broker.InsertExamAttachmentAsync(invalidExamAttachment))
.ThrowsAsync(foreignKeyConstraintConflictException);
// when
ValueTask <ExamAttachment> addExamAttachmentTask =
this.examAttachmentService.AddExamAttachmentAsync(invalidExamAttachment);
// then
await Assert.ThrowsAsync <ExamAttachmentValidationException>(() =>
addExamAttachmentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedExamAttachmentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertExamAttachmentAsync(invalidExamAttachment),
Times.Once);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidatonExceptionOnRetrieveWhenAttachmentIdIsInvalidAndLogItAsync()
{
// given
Guid randomAttachmentId = default;
Guid randomExamId = Guid.NewGuid();
Guid invalidAttachmentId = randomAttachmentId;
Guid inputExamId = randomExamId;
var invalidExamAttachmentInputException = new InvalidExamAttachmentException(
parameterName: nameof(ExamAttachment.AttachmentId),
parameterValue: invalidAttachmentId);
var expectedExamAttachmentValidationException =
new ExamAttachmentValidationException(invalidExamAttachmentInputException);
// when
ValueTask <ExamAttachment> retrieveExamAttachmentTask =
this.examAttachmentService.RetrieveExamAttachmentByIdAsync(
inputExamId,
invalidAttachmentId);
// then
await Assert.ThrowsAsync <ExamAttachmentValidationException>(() =>
retrieveExamAttachmentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedExamAttachmentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectExamAttachmentByIdAsync(It.IsAny <Guid>(), It.IsAny <Guid>()),
Times.Never);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
