public async Task ShouldThrowValidationExceptionOnModifyWhenRegistrationIsNullAndLogItAsync()
{
//given
Registration invalidRegistration = null;
var nullRegistrationException = new NullRegistrationException();
var expectedRegistrationValidationException =
new RegistrationValidationException(nullRegistrationException);
//when
ValueTask <Registration> modifyRegistrationTask =
this.registrationService.ModifyRegistrationAsync(invalidRegistration);
//then
await Assert.ThrowsAsync <RegistrationValidationException>(() =>
modifyRegistrationTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedRegistrationValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnModifyWhenRegistrationIdIsInvalidAndLogItAsync()
{
//given
Guid invalidRegistrationId = Guid.Empty;
DateTimeOffset dateTime = GetRandomDateTime();
Registration randomRegistration = CreateRandomRegistration(dateTime);
Registration invalidRegistration = randomRegistration;
invalidRegistration.Id = invalidRegistrationId;
var invalidRegistrationException = new InvalidRegistrationException(
parameterName: nameof(Registration.Id),
parameterValue: invalidRegistration.Id);
var expectedRegistrationValidationException =
new RegistrationValidationException(invalidRegistrationException);
//when
ValueTask <Registration> modifyRegistrationTask =
this.registrationService.ModifyRegistrationAsync(invalidRegistration);
//then
await Assert.ThrowsAsync <RegistrationValidationException>(() =>
modifyRegistrationTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedRegistrationValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenRegistrationIsNullAndLogItAsync()
{
// given
Registration randomRegistration = default;
Registration nullRegistration = randomRegistration;
var nullRegistrationException = new NullRegistrationException();
var expectedRegistrationValidationException =
new RegistrationValidationException(nullRegistrationException);
// when
ValueTask <Registration> createRegistrationTask =
this.registrationService.AddRegistrationAsync(nullRegistration);
// then
await Assert.ThrowsAsync <RegistrationValidationException>(() =>
createRegistrationTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedRegistrationValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertRegistrationAsync(It.IsAny <Registration>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
private RegistrationValidationException CreateAndLogValidationException(Exception exception)
{
var RegistrationValidationException = new RegistrationValidationException(exception);
this.loggingBroker.LogError(RegistrationValidationException);
return(RegistrationValidationException);
}
ShouldThrowValidationExceptionOnModifyWhenCreatedByIsNotSameAsStorageCreatedByIsInvalidAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
Guid randomCreatedById = Guid.NewGuid();
int randomNumber = GetRandomNumber();
Registration randomRegistration = CreateRandomRegistration(dateTime);
Registration inputRegistration = randomRegistration;
inputRegistration.CreatedDate = dateTime.AddMinutes(randomNumber * -1);
Registration storageRegistration = randomRegistration.DeepClone();
storageRegistration.CreatedBy = randomCreatedById;
var invalidRegistrationInputException = new InvalidRegistrationException(
parameterName: nameof(Registration.CreatedBy),
parameterValue: inputRegistration.CreatedBy);
var expectedRegistrationValidationException =
new RegistrationValidationException(invalidRegistrationInputException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
this.storageBrokerMock.Setup(broker =>
broker.SelectRegistrationByIdAsync(inputRegistration.Id))
.ReturnsAsync(storageRegistration);
// when
ValueTask <Registration> modifyRegistrationTask =
this.registrationService.ModifyRegistrationAsync(inputRegistration);
// then
await Assert.ThrowsAsync <RegistrationValidationException>(() =>
modifyRegistrationTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectRegistrationByIdAsync(It.IsAny <Guid>()),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedRegistrationValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.UpdateRegistrationAsync(It.IsAny <Registration>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnModifyIfRegistrationDoesntExistAndLogItAsync()
{
// given
int randomNegativeMinutes = GetNegativeRandomNumber();
DateTimeOffset dateTime = GetRandomDateTime();
Registration randomRegistration = CreateRandomRegistration(dateTime);
Registration nonExistentRegistration = randomRegistration;
nonExistentRegistration.CreatedDate = dateTime.AddMinutes(randomNegativeMinutes);
Registration noRegistration = null;
var notFoundRegistrationException = new NotFoundRegistrationException(nonExistentRegistration.Id);
var expectedRegistrationValidationException =
new RegistrationValidationException(notFoundRegistrationException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
this.storageBrokerMock.Setup(broker =>
broker.SelectRegistrationByIdAsync(nonExistentRegistration.Id))
.ReturnsAsync(noRegistration);
// when
ValueTask <Registration> modifyRegistrationTask =
this.registrationService.ModifyRegistrationAsync(nonExistentRegistration);
// then
await Assert.ThrowsAsync <RegistrationValidationException>(() =>
modifyRegistrationTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectRegistrationByIdAsync(nonExistentRegistration.Id),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedRegistrationValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.UpdateRegistrationAsync(It.IsAny <Registration>()),
Times.Never);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenRegistrationAlreadyExistsAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
Registration randomRegistration = CreateRandomRegistration(dateTime);
Registration alreadyExistsRegistration = randomRegistration;
alreadyExistsRegistration.UpdatedBy = alreadyExistsRegistration.CreatedBy;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var duplicateKeyException = new DuplicateKeyException(exceptionMessage);
var alreadyExistsRegistrationException =
new AlreadyExistsRegistrationException(duplicateKeyException);
var expectedRegistrationValidationException =
new RegistrationValidationException(alreadyExistsRegistrationException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
this.storageBrokerMock.Setup(broker =>
broker.InsertRegistrationAsync(alreadyExistsRegistration))
.ThrowsAsync(duplicateKeyException);
// when
ValueTask <Registration> registerRegistrationTask =
this.registrationService.AddRegistrationAsync(alreadyExistsRegistration);
// then
await Assert.ThrowsAsync <RegistrationValidationException>(() =>
registerRegistrationTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertRegistrationAsync(alreadyExistsRegistration),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedRegistrationValidationException))),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnModifyWhenUpdatedDateIsNotRecentAndLogItAsync(
int minutes)
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
Registration randomRegistration = CreateRandomRegistration(dateTime);
Registration inputRegistration = randomRegistration;
inputRegistration.UpdatedDate = dateTime.AddMinutes(minutes);
var invalidRegistrationInputException = new InvalidRegistrationException(
parameterName: nameof(Registration.UpdatedDate),
parameterValue: inputRegistration.UpdatedDate);
var expectedRegistrationValidationException =
new RegistrationValidationException(invalidRegistrationInputException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
// when
ValueTask <Registration> modifyRegistrationTask =
this.registrationService.ModifyRegistrationAsync(inputRegistration);
// then
await Assert.ThrowsAsync <RegistrationValidationException>(() =>
modifyRegistrationTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedRegistrationValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectRegistrationByIdAsync(It.IsAny <Guid>()),
Times.Never);
this.storageBrokerMock.Verify(broker =>
broker.UpdateRegistrationAsync(It.IsAny <Registration>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnModifyWhenSubmitterEmailIsInvalidAndLogItAsync(
string invalidRegistrationSubmitterEmail)
{
// given
DateTimeOffset datetime = GetRandomDateTime();
Registration randomRegistration = CreateRandomRegistration(datetime);
Registration invalidRegistration = randomRegistration;
invalidRegistration.SubmitterEmail = invalidRegistrationSubmitterEmail;
var invalidRegistrationInputException = new InvalidRegistrationException(
parameterName: nameof(Registration.SubmitterEmail),
parameterValue: invalidRegistration.SubmitterEmail);
var expectedRegistrationValidationException =
new RegistrationValidationException(invalidRegistrationInputException);
// when
ValueTask <Registration> modifyRegistrationTask =
this.registrationService.ModifyRegistrationAsync(invalidRegistration);
// then
await Assert.ThrowsAsync <RegistrationValidationException>(() =>
modifyRegistrationTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedRegistrationValidationException))),
Times.Once);
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Never);
this.storageBrokerMock.Verify(broker =>
broker.SelectRegistrationByIdAsync(It.IsAny <Guid>()),
Times.Never);
this.storageBrokerMock.Verify(broker =>
broker.UpdateRegistrationAsync(It.IsAny <Registration>()),
Times.Never);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnRemoveIfRegistrationIsNotFoundAndLogItAsync()
{
// given
DateTimeOffset randomDateTime = GetRandomDateTime();
Registration randomRegistration = CreateRandomRegistration(dateTime: randomDateTime);
Guid inputRegistrationId = randomRegistration.Id;
Registration noRegistration = null;
var notFoundRegistrationException =
new NotFoundRegistrationException(randomRegistration.Id);
var expectedRegistrationValidationException =
new RegistrationValidationException(notFoundRegistrationException);
this.storageBrokerMock.Setup(broker =>
broker.SelectRegistrationByIdAsync(It.IsAny <Guid>())).
ReturnsAsync(noRegistration);
// when
ValueTask <Registration> removeRegistrationByIdTask =
this.registrationService.RemoveRegistrationByIdAsync(inputRegistrationId);
// then
await Assert.ThrowsAsync <RegistrationValidationException>(() =>
removeRegistrationByIdTask.AsTask());
this.storageBrokerMock.Verify(broker =>
broker.SelectRegistrationByIdAsync(It.IsAny <Guid>()),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.DeleteRegistrationAsync(It.IsAny <Registration>()),
Times.Never);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedRegistrationValidationException))),
Times.Once);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnRetrieveByIdWhenStorageRegistrationIsNullAndLogItAsync()
{
//given
Guid randomRegistrationId = Guid.NewGuid();
Guid someRegistrationId = randomRegistrationId;
Registration invalidStorageRegistration = null;
var notFoundRegistrationException = new NotFoundRegistrationException(someRegistrationId);
var expectedRegistrationValidationException =
new RegistrationValidationException(notFoundRegistrationException);
this.storageBrokerMock.Setup(broker =>
broker.SelectRegistrationByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(invalidStorageRegistration);
//when
ValueTask <Registration> retrieveRegistrationByIdTask =
this.registrationService.RetrieveRegistrationByIdAsync(someRegistrationId);
//then
await Assert.ThrowsAsync <RegistrationValidationException>(() =>
retrieveRegistrationByIdTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedRegistrationValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectRegistrationByIdAsync(It.IsAny <Guid>()),
Times.Once);
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Never);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnAddWhenStudentEmailIsInvalidAndLogItAsync(
string invalidRegistrationStudentEmail)
{
// given
DateTimeOffset datetime = DateTimeOffset.UtcNow;
Registration randomRegistration = CreateRandomRegistration(datetime);
Registration invalidRegistration = randomRegistration;
invalidRegistration.StudentEmail = invalidRegistrationStudentEmail;
var invalidRegistrationInputException = new InvalidRegistrationException(
parameterName: nameof(Registration.StudentEmail),
parameterValue: invalidRegistration.StudentEmail);
var expectedRegistrationValidationException =
new RegistrationValidationException(invalidRegistrationInputException);
// when
ValueTask <Registration> registerRegistrationTask =
this.registrationService.AddRegistrationAsync(invalidRegistration);
// then
await Assert.ThrowsAsync <RegistrationValidationException>(() =>
registerRegistrationTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedRegistrationValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertRegistrationAsync(It.IsAny <Registration>()),
Times.Never);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenUpdatedDateIsNotSameToCreatedDateAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
Registration randomRegistration = CreateRandomRegistration(dateTime);
Registration inputRegistration = randomRegistration;
inputRegistration.UpdatedBy = randomRegistration.CreatedBy;
inputRegistration.UpdatedDate = GetRandomDateTime();
var invalidRegistrationInputException = new InvalidRegistrationException(
parameterName: nameof(Registration.UpdatedDate),
parameterValue: inputRegistration.UpdatedDate);
var expectedRegistrationValidationException =
new RegistrationValidationException(invalidRegistrationInputException);
// when
ValueTask <Registration> registerRegistrationTask =
this.registrationService.AddRegistrationAsync(inputRegistration);
// then
await Assert.ThrowsAsync <RegistrationValidationException>(() =>
registerRegistrationTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedRegistrationValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertRegistrationAsync(It.IsAny <Registration>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnRemoveIfIdIsInvalidAndLogItAsync()
{
// given
Guid invalidTaskCategotyId = Guid.Empty;
var invalidRegistrationException = new InvalidRegistrationException(
parameterName: nameof(Registration.Id),
parameterValue: invalidTaskCategotyId);
var expectedRegistrationValidationException =
new RegistrationValidationException(invalidRegistrationException);
// when
ValueTask <Registration> deleteRegistrationTask =
this.registrationService.RemoveRegistrationByIdAsync(invalidTaskCategotyId);
// then
await Assert.ThrowsAsync <RegistrationValidationException>(() =>
deleteRegistrationTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedRegistrationValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectRegistrationByIdAsync(It.IsAny <Guid>()),
Times.Never);
this.storageBrokerMock.Verify(broker =>
broker.DeleteRegistrationAsync(It.IsAny <Registration>()),
Times.Never);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnRetrieveByIdWhenIdIsInvalidAndLogItAsync()
{
//given
Guid randomRegistrationId = default;
Guid inputRegistrationId = randomRegistrationId;
var invalidRegistrationException = new InvalidRegistrationException(
parameterName: nameof(Registration.Id),
parameterValue: inputRegistrationId);
var expectedRegistrationValidationException =
new RegistrationValidationException(invalidRegistrationException);
//when
ValueTask <Registration> retrieveRegistrationByIdTask =
this.registrationService.RetrieveRegistrationByIdAsync(inputRegistrationId);
//then
await Assert.ThrowsAsync <RegistrationValidationException>(() => retrieveRegistrationByIdTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedRegistrationValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectRegistrationByIdAsync(It.IsAny <Guid>()),
Times.Never);
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Never);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationOnModifyIfForeignKeyConstraintConflictExceptionOccursAndLogItAsync()
{
// given
DateTimeOffset randomDateTime = GetRandomDateTime();
DateTimeOffset dateTime = randomDateTime;
Registration randomRegistration = CreateRandomRegistration(dateTime);
Registration storageRegistration = randomRegistration;
Registration foreignKeyConflictedRegistration = storageRegistration.DeepClone();
storageRegistration.UpdatedDate = dateTime.AddMinutes(GetNegativeRandomNumber());
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var foreignKeyConstraintConflictException =
new ForeignKeyConstraintConflictException(exceptionMessage);
var invalidRegistrationReferenceException =
new InvalidRegistrationReferenceException(foreignKeyConstraintConflictException);
var registrationValidationException =
new RegistrationValidationException(invalidRegistrationReferenceException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(randomDateTime);
this.storageBrokerMock.Setup(broker =>
broker.SelectRegistrationByIdAsync(foreignKeyConflictedRegistration.Id))
.ReturnsAsync(storageRegistration);
this.storageBrokerMock.Setup(broker =>
broker.UpdateRegistrationAsync(foreignKeyConflictedRegistration))
.ThrowsAsync(foreignKeyConstraintConflictException);
// when
ValueTask <Registration> modifyRegistrationTask =
this.registrationService.ModifyRegistrationAsync(foreignKeyConflictedRegistration);
// then
await Assert.ThrowsAsync <RegistrationValidationException>(() =>
modifyRegistrationTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectRegistrationByIdAsync(foreignKeyConflictedRegistration.Id),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.UpdateRegistrationAsync(foreignKeyConflictedRegistration),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(registrationValidationException))),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
