public async Task ShouldThrowValidationExceptionOnModifyWhenAssignmentIsNullAndLogItAsync()
{
//given
Assignment invalidAssignment = null;
var nullAssignmentException = new NullAssignmentException();
var expectedAssignmentValidationException =
new AssignmentValidationException(nullAssignmentException);
//when
ValueTask <Assignment> modifyAssignmentTask =
this.assignmentService.ModifyAssignmentAsync(invalidAssignment);
//then
await Assert.ThrowsAsync <AssignmentValidationException>(() =>
modifyAssignmentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedAssignmentValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnCreateWhenAssignmentLabelIsInvalidAndLogItAsync(
string invalidAssignmentLabel)
{
// given
Assignment randomAssignment = CreateRandomAssignment();
Assignment invalidAssignment = randomAssignment;
invalidAssignment.Label = invalidAssignmentLabel;
var invalidAssignmentException = new InvalidAssignmentException(
parameterName: nameof(Assignment.Label),
parameterValue: invalidAssignment.Label);
var expectedAssignmentValidationException =
new AssignmentValidationException(invalidAssignmentException);
// when
ValueTask <Assignment> createAssignmentTask =
this.assignmentService.CreateAssignmentAsync(invalidAssignment);
// then
await Assert.ThrowsAsync <AssignmentValidationException>(() =>
createAssignmentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedAssignmentValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnCreateWhenAssignmentIsNullAndLogItAsync()
{
// given
Assignment randomAssignment = null;
Assignment nullAssignment = randomAssignment;
var nullAssignmentException = new NullAssignmentException();
var expectedAssignmentValidationException =
new AssignmentValidationException(nullAssignmentException);
// when
ValueTask <Assignment> createAssignmentTask =
this.assignmentService.CreateAssignmentAsync(nullAssignment);
// then
await Assert.ThrowsAsync <AssignmentValidationException>(() =>
createAssignmentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedAssignmentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectAssignmentByIdAsync(It.IsAny <Guid>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnModifyWhenAssignmentIdIsInvalidAndLogItAsync()
{
//given
Guid invalidAssignmentId = Guid.Empty;
DateTimeOffset dateTime = GetRandomDateTime();
Assignment randomAssignment = CreateRandomAssignment(dateTime);
Assignment invalidAssignment = randomAssignment;
invalidAssignment.Id = invalidAssignmentId;
var invalidAssignmentException = new InvalidAssignmentException(
parameterName: nameof(Assignment.Id),
parameterValue: invalidAssignment.Id);
var expectedAssignmentValidationException =
new AssignmentValidationException(invalidAssignmentException);
//when
ValueTask <Assignment> modifyAssignmentTask =
this.assignmentService.ModifyAssignmentAsync(invalidAssignment);
//then
await Assert.ThrowsAsync <AssignmentValidationException>(() =>
modifyAssignmentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedAssignmentValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnModifyWhenUpdatedDateIsSameAsCreatedDateAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
Assignment randomAssignment = CreateRandomAssignment(dateTime);
Assignment inputAssignment = randomAssignment;
var invalidAssignmentInputException = new InvalidAssignmentException(
parameterName: nameof(Assignment.UpdatedDate),
parameterValue: inputAssignment.UpdatedDate);
var expectedAssignmentValidationException =
new AssignmentValidationException(invalidAssignmentInputException);
// when
ValueTask <Assignment> modifyAssignmentTask =
this.assignmentService.ModifyAssignmentAsync(inputAssignment);
// then
await Assert.ThrowsAsync <AssignmentValidationException>(() =>
modifyAssignmentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedAssignmentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectAssignmentByIdAsync(It.IsAny <Guid>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnRetrieveWhenIdIsInvalidAndLogItAsync()
{
//given
Guid randomAssignmentId = default;
Guid inputAssignmentId = randomAssignmentId;
var invalidAssignmentInputException = new InvalidAssignmentException(
parameterName: nameof(Assignment.Id),
parameterValue: inputAssignmentId);
var expectedAssignmentValidationException = new AssignmentValidationException(invalidAssignmentInputException);
//when
ValueTask <Assignment> retrieveAssignmentByIdTask =
this.assignmentService.RetrieveAssignmentById(inputAssignmentId);
//then
await Assert.ThrowsAsync <AssignmentValidationException>(() => retrieveAssignmentByIdTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedAssignmentValidationException))),
Times.Once
);
this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(),
Times.Never);
this.storageBrokerMock.Verify(broker =>
broker.SelectAssignmentByIdAsync(It.IsAny <Guid>()),
Times.Never);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
private AssignmentValidationException CreateAndLogValidationException(Exception exception)
{
var assignmentValidationException = new AssignmentValidationException(exception);
this.loggingBroker.LogError(assignmentValidationException);
return(assignmentValidationException);
}
public async Task ShouldThrowValidationExceptionOnModifyIfStorageCreatedByNotSameAsCreatedByAndLogItAsync()
{
// given
int randomNegativeMinutes = GetNegativeRandomNumber();
Guid differentId = Guid.NewGuid();
Guid invalidCreatedBy = differentId;
DateTimeOffset randomDate = GetRandomDateTime();
Assignment randomAssignment = CreateRandomAssignment(randomDate);
Assignment invalidAssignment = randomAssignment;
invalidAssignment.CreatedDate = randomDate.AddMinutes(randomNegativeMinutes);
Assignment storageAssignment = randomAssignment.DeepClone();
Guid assignmentId = invalidAssignment.Id;
invalidAssignment.CreatedBy = invalidCreatedBy;
var invalidAssignmentInputException = new InvalidAssignmentException(
parameterName: nameof(Assignment.CreatedBy),
parameterValue: invalidAssignment.CreatedBy);
var expectedAssignmentValidationException =
new AssignmentValidationException(invalidAssignmentInputException);
this.storageBrokerMock.Setup(broker =>
broker.SelectAssignmentByIdAsync(assignmentId))
.ReturnsAsync(storageAssignment);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(randomDate);
// when
ValueTask <Assignment> modifyAssignmentTask =
this.assignmentService.ModifyAssignmentAsync(invalidAssignment);
// then
await Assert.ThrowsAsync <AssignmentValidationException>(() =>
modifyAssignmentTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectAssignmentByIdAsync(invalidAssignment.Id),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedAssignmentValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnCreateWhenAssignmentAlreadyExistsAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
Assignment randomAssignment = CreateRandomAssignment(dateTime);
Assignment alreadyExistsAssignment = randomAssignment;
alreadyExistsAssignment.UpdatedBy = alreadyExistsAssignment.CreatedBy;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var duplicateKeyException = new DuplicateKeyException(exceptionMessage);
var alreadyExistsAssignmentException =
new AlreadyExistsAssignmentException(duplicateKeyException);
var expectedAssignmentValidationException =
new AssignmentValidationException(alreadyExistsAssignmentException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
this.storageBrokerMock.Setup(broker =>
broker.InsertAssignmentAsync(alreadyExistsAssignment))
.ThrowsAsync(duplicateKeyException);
// when
ValueTask <Assignment> createAssignmentTask =
this.assignmentService.CreateAssignmentAsync(alreadyExistsAssignment);
// then
await Assert.ThrowsAsync <AssignmentValidationException>(() =>
createAssignmentTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertAssignmentAsync(alreadyExistsAssignment),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedAssignmentValidationException))),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnCreateWhenCreatedDateIsNotRecentAndLogItAsync(
int minutes)
{
// given
DateTimeOffset randomDate = GetRandomDateTime();
Assignment randomAssignment = CreateRandomAssignment(randomDate);
Assignment invalidAssignment = randomAssignment;
invalidAssignment.CreatedDate = randomDate.AddMinutes(minutes);
invalidAssignment.UpdatedDate = invalidAssignment.CreatedDate;
var invalidAssignmentException = new InvalidAssignmentException();
invalidAssignmentException.AddData(
key: nameof(Assignment.CreatedDate),
values: $"Date is not recent");
var expectedAssignmentValidationException =
new AssignmentValidationException(invalidAssignmentException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(randomDate);
// when
ValueTask <Assignment> createAssignmentTask =
this.assignmentService.CreateAssignmentAsync(invalidAssignment);
// then
await Assert.ThrowsAsync <AssignmentValidationException>(() =>
createAssignmentTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameValidationExceptionAs(
expectedAssignmentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertAssignmentAsync(It.IsAny <Assignment>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnModifyIfAssignmentDoesntExistAndLogItAsync()
{
// given
int randomNegativeMinutes = GetNegativeRandomNumber();
DateTimeOffset dateTime = GetRandomDateTime();
Assignment randomAssignment = CreateRandomAssignment(dateTime);
Assignment nonExistentAssignment = randomAssignment;
nonExistentAssignment.CreatedDate = dateTime.AddMinutes(randomNegativeMinutes);
Assignment noAssignment = null;
var notFoundAssignmentException = new NotFoundAssignmentException(nonExistentAssignment.Id);
var expectedAssignmentValidationException =
new AssignmentValidationException(notFoundAssignmentException);
this.storageBrokerMock.Setup(broker =>
broker.SelectAssignmentByIdAsync(nonExistentAssignment.Id))
.ReturnsAsync(noAssignment);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
// when
ValueTask <Assignment> modifyAssignmentTask =
this.assignmentService.ModifyAssignmentAsync(nonExistentAssignment);
// then
await Assert.ThrowsAsync <AssignmentValidationException>(() =>
modifyAssignmentTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectAssignmentByIdAsync(nonExistentAssignment.Id),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedAssignmentValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnCreateWhenUpdatedByIsNotSameToCreatedByAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
Assignment randomAssignment = CreateRandomAssignment(dateTime);
Assignment invalidAssignment = randomAssignment;
invalidAssignment.UpdatedBy = Guid.NewGuid();
var invalidAssignmentInputException = new InvalidAssignmentException();
invalidAssignmentInputException.AddData(
key: nameof(Assignment.UpdatedBy),
values: $"Id is not the same as {nameof(Assignment.CreatedBy)}");
var expectedAssignmentValidationException =
new AssignmentValidationException(invalidAssignmentInputException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
// when
ValueTask <Assignment> createAssignmentTask =
this.assignmentService.CreateAssignmentAsync(invalidAssignment);
// then
await Assert.ThrowsAsync <AssignmentValidationException>(() =>
createAssignmentTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameValidationExceptionAs(
expectedAssignmentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertAssignmentAsync(It.IsAny <Assignment>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidatonExceptionOnRemoveWhenStorageAssignmentIsInvalidAndLogItAsync()
{
// given
DateTimeOffset dateTimeOffset = GetRandomDateTime();
Assignment randomAssignment = CreateRandomAssignment(dates: dateTimeOffset);
Guid inputAssignmentId = randomAssignment.Id;
Assignment inputAssignment = randomAssignment;
Assignment nullStorageAssignment = null;
var notFoundAssignmentException = new NotFoundAssignmentException(inputAssignmentId);
var expectedAssignmentValidationException =
new AssignmentValidationException(notFoundAssignmentException);
this.storageBrokerMock.Setup(broker =>
broker.SelectAssignmentByIdAsync(inputAssignmentId))
.ReturnsAsync(nullStorageAssignment);
// when
ValueTask <Assignment> actualAssignmentTask =
this.assignmentService.RemoveAssignmentByIdAsync(inputAssignmentId);
// then
await Assert.ThrowsAsync <AssignmentValidationException>(() => actualAssignmentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedAssignmentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectAssignmentByIdAsync(inputAssignmentId),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.DeleteAssignmentAsync(It.IsAny <Assignment>()),
Times.Never);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnRetrieveWhenStorageAssignmentIsNullAndLogItAsync()
{
//given
Guid randomAssignmentId = Guid.NewGuid();
Guid inputAssignmentId = randomAssignmentId;
Assignment invalidStorageAssignment = null;
var notFoundAssignmentException = new NotFoundAssignmentException(inputAssignmentId);
var expectedAssignmentValidationException = new AssignmentValidationException(notFoundAssignmentException);
this.storageBrokerMock.Setup(broker =>
broker.SelectAssignmentByIdAsync(inputAssignmentId))
.ReturnsAsync(invalidStorageAssignment);
//when
ValueTask <Assignment> retrieveAssignmentByIdTask =
this.assignmentService.RetrieveAssignmentByIdAsync(inputAssignmentId);
//then
await Assert.ThrowsAsync <AssignmentValidationException>(() =>
retrieveAssignmentByIdTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedAssignmentValidationException))),
Times.Once);
this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(),
Times.Never);
this.storageBrokerMock.Verify(broker =>
broker.SelectAssignmentByIdAsync(It.IsAny <Guid>()),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnModifyWhenAssignmentIsInvalidAndLogItAsync(
string invalidText)
{
// given
var invalidAssignment = new Assignment
{
Label = invalidText,
Content = invalidText
};
var invalidAssignmentException = new InvalidAssignmentException();
invalidAssignmentException.AddData(
key: nameof(Assignment.Id),
values: "Id is required");
invalidAssignmentException.AddData(
key: nameof(Assignment.Label),
values: "Text is required");
invalidAssignmentException.AddData(
key: nameof(Assignment.Content),
values: "Text is required");
invalidAssignmentException.AddData(
key: nameof(Assignment.Deadline),
values: "Date is required");
invalidAssignmentException.AddData(
key: nameof(Assignment.CreatedBy),
values: "Id is required");
invalidAssignmentException.AddData(
key: nameof(Assignment.UpdatedBy),
values: "Id is required");
invalidAssignmentException.AddData(
key: nameof(Assignment.CreatedDate),
values: "Date is required");
invalidAssignmentException.AddData(
key: nameof(Assignment.UpdatedDate),
values: "Date is required");
var expectedAssignmentValidationException =
new AssignmentValidationException(invalidAssignmentException);
//when
ValueTask <Assignment> modifyAssignmentTask =
this.assignmentService.ModifyAssignmentAsync(invalidAssignment);
//then
await Assert.ThrowsAsync <AssignmentValidationException>(() =>
modifyAssignmentTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedAssignmentValidationException))),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
