public async Task ShouldThrowValidationExceptionOnModifyWhenGuardianIdIsInvalidAndLogItAsync()
{
//given
Guid invalidStudentGuardianId = Guid.Empty;
DateTimeOffset dateTime = GetRandomDateTime();
StudentGuardian randomStudentGuardian = CreateRandomStudentGuardian(dateTime);
StudentGuardian invalidStudentGuardian = randomStudentGuardian;
invalidStudentGuardian.GuardianId = invalidStudentGuardianId;
var invalidStudentGuardianInputException = new InvalidStudentGuardianInputException(
parameterName: nameof(StudentGuardian.GuardianId),
parameterValue: invalidStudentGuardian.GuardianId);
var expectedStudentGuardianValidationException =
new StudentGuardianValidationException(invalidStudentGuardianInputException);
//when
ValueTask <StudentGuardian> modifyStudentGuardianTask =
this.studentGuardianService.ModifyStudentGuardianAsync(invalidStudentGuardian);
//then
await Assert.ThrowsAsync <StudentGuardianValidationException>(() =>
modifyStudentGuardianTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentGuardianValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnModifyWhenStudentGuardianIsNullAndLogItAsync()
{
//given
StudentGuardian invalidStudentGuardian = null;
var nullStudentGuardianException = new NullStudentGuardianException();
var expectedStudentGuardianValidationException =
new StudentGuardianValidationException(nullStudentGuardianException);
//when
ValueTask <StudentGuardian> modifyStudentGuardianTask =
this.studentGuardianService.ModifyStudentGuardianAsync(invalidStudentGuardian);
//then
await Assert.ThrowsAsync <StudentGuardianValidationException>(() =>
modifyStudentGuardianTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentGuardianValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnModifyWhenUpdatedDateIsSameAsCreatedDateAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
StudentGuardian randomStudentGuardian = CreateRandomStudentGuardian(dateTime);
StudentGuardian inputStudentGuardian = randomStudentGuardian;
var invalidStudentGuardianInputException = new InvalidStudentGuardianInputException(
parameterName: nameof(StudentGuardian.UpdatedDate),
parameterValue: inputStudentGuardian.UpdatedDate);
var expectedStudentGuardianValidationException =
new StudentGuardianValidationException(invalidStudentGuardianInputException);
// when
ValueTask <StudentGuardian> modifyStudentGuardianTask =
this.studentGuardianService.ModifyStudentGuardianAsync(inputStudentGuardian);
// then
await Assert.ThrowsAsync <StudentGuardianValidationException>(() =>
modifyStudentGuardianTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentGuardianValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectStudentGuardianByIdAsync(It.IsAny <Guid>(), It.IsAny <Guid>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidatonExceptionOnRetrieveWhenGuardianIdIsInvalidAndLogItAsync()
{
// given
Guid randomGuardianId = default;
Guid randomStudentId = Guid.NewGuid();
Guid inputGuardianId = randomGuardianId;
Guid inputStudentId = randomStudentId;
var invalidStudentGuardianInputException = new InvalidStudentGuardianInputException(
parameterName: nameof(StudentGuardian.GuardianId),
parameterValue: inputGuardianId);
var expectedStudentGuardianValidationException =
new StudentGuardianValidationException(invalidStudentGuardianInputException);
// when
ValueTask <StudentGuardian> actualStudentGuardianTask =
this.studentGuardianService.RetrieveStudentGuardianByIdAsync(inputStudentId, inputGuardianId);
// then
await Assert.ThrowsAsync <StudentGuardianValidationException>(() => actualStudentGuardianTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentGuardianValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectStudentGuardianByIdAsync(It.IsAny <Guid>(), It.IsAny <Guid>()),
Times.Never);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenStudentGuardianIsNullAndLogItAsync()
{
// given
StudentGuardian randomStudentGuardian = default;
StudentGuardian nullStudentGuardian = randomStudentGuardian;
var nullStudentGuardianException = new NullStudentGuardianException();
var expectedStudentGuardianValidationException =
new StudentGuardianValidationException(nullStudentGuardianException);
// when
ValueTask <StudentGuardian> addStudentGuardianTask =
this.studentGuardianService.AddStudentGuardianAsync(nullStudentGuardian);
// then
await Assert.ThrowsAsync <StudentGuardianValidationException>(() =>
addStudentGuardianTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentGuardianValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertStudentGuardianAsync(It.IsAny <StudentGuardian>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
private StudentGuardianValidationException CreateAndLogValidationException(Exception exception)
{
var StudentGuardianValidationException = new StudentGuardianValidationException(exception);
this.loggingBroker.LogError(StudentGuardianValidationException);
return(StudentGuardianValidationException);
}
public async Task ShouldThrowValidationExceptionOnModifyIfStorageCreatedDateNotSameAsCreateDateAndLogItAsync()
{
// given
int randomNumber = GetRandomNumber();
int randomMinutes = randomNumber;
DateTimeOffset randomDate = GetRandomDateTime();
StudentGuardian randomStudentGuardian = CreateRandomStudentGuardian(randomDate);
StudentGuardian invalidStudentGuardian = randomStudentGuardian;
invalidStudentGuardian.UpdatedDate = randomDate;
StudentGuardian storageStudentGuardian = randomStudentGuardian.DeepClone();
Guid studentId = invalidStudentGuardian.StudentId;
Guid semesterCourseId = invalidStudentGuardian.GuardianId;
invalidStudentGuardian.CreatedDate = storageStudentGuardian.CreatedDate.AddMinutes(randomNumber);
var invalidStudentGuardianInputException = new InvalidStudentGuardiantException(
parameterName: nameof(StudentGuardian.CreatedDate),
parameterValue: invalidStudentGuardian.CreatedDate);
var expectedStudentGuardianValidationException =
new StudentGuardianValidationException(invalidStudentGuardianInputException);
this.storageBrokerMock.Setup(broker =>
broker.SelectStudentGuardianByIdAsync(studentId, semesterCourseId))
.ReturnsAsync(storageStudentGuardian);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(randomDate);
// when
ValueTask <StudentGuardian> modifyStudentGuardianTask =
this.studentGuardianService.ModifyStudentGuardianAsync(invalidStudentGuardian);
// then
await Assert.ThrowsAsync <StudentGuardianValidationException>(() =>
modifyStudentGuardianTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectStudentGuardianByIdAsync(
invalidStudentGuardian.StudentId,
invalidStudentGuardian.GuardianId),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedStudentGuardianValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnModifyIfStudentGuardianDoesntExistAndLogItAsync()
{
// given
int randomNegativeMinutes = GetNegativeRandomNumber();
DateTimeOffset dateTime = GetRandomDateTime();
StudentGuardian randomStudentGuardian = CreateRandomStudentGuardian(dateTime);
StudentGuardian nonExistentStudentGuardian = randomStudentGuardian;
nonExistentStudentGuardian.CreatedDate = dateTime.AddMinutes(randomNegativeMinutes);
StudentGuardian noStudentGuardian = null;
var notFoundStudentGuardianException = new NotFoundStudentGuardianException
(nonExistentStudentGuardian.StudentId, nonExistentStudentGuardian.GuardianId);
var expectedStudentGuardianValidationException =
new StudentGuardianValidationException(notFoundStudentGuardianException);
this.storageBrokerMock.Setup(broker =>
broker.SelectStudentGuardianByIdAsync(
nonExistentStudentGuardian.StudentId, nonExistentStudentGuardian.GuardianId))
.ReturnsAsync(noStudentGuardian);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
// when
ValueTask <StudentGuardian> modifyStudentGuardianTask =
this.studentGuardianService.ModifyStudentGuardianAsync(nonExistentStudentGuardian);
// then
await Assert.ThrowsAsync <StudentGuardianValidationException>(() =>
modifyStudentGuardianTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectStudentGuardianByIdAsync
(nonExistentStudentGuardian.StudentId, nonExistentStudentGuardian.GuardianId),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedStudentGuardianValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenStudentGuardianAlreadyExistsAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
StudentGuardian randomStudentGuardian = CreateRandomStudentGuardian(dateTime);
StudentGuardian alreadyExistsStudentGuardian = randomStudentGuardian;
alreadyExistsStudentGuardian.UpdatedBy = alreadyExistsStudentGuardian.CreatedBy;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var duplicateKeyException = new DuplicateKeyException(exceptionMessage);
var alreadyExistsStudentGuardianException =
new AlreadyExistsStudentGuardianException(duplicateKeyException);
var expectedStudentGuardianValidationException =
new StudentGuardianValidationException(alreadyExistsStudentGuardianException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
this.storageBrokerMock.Setup(broker =>
broker.InsertStudentGuardianAsync(alreadyExistsStudentGuardian))
.ThrowsAsync(duplicateKeyException);
// when
ValueTask <StudentGuardian> createStudentGuardianTask =
this.studentGuardianService.AddStudentGuardianAsync(alreadyExistsStudentGuardian);
// then
await Assert.ThrowsAsync <StudentGuardianValidationException>(() =>
createStudentGuardianTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedStudentGuardianValidationException))),
Times.Once);
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertStudentGuardianAsync(alreadyExistsStudentGuardian),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenCreatedDateIsNotRecentAndLogItAsync(
int invalidMinutes)
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
StudentGuardian randomStudentGuardian = CreateRandomStudentGuardian(dateTime);
StudentGuardian inputStudentGuardian = randomStudentGuardian;
inputStudentGuardian.UpdatedBy = inputStudentGuardian.CreatedBy;
inputStudentGuardian.CreatedDate = dateTime.AddMinutes(invalidMinutes);
inputStudentGuardian.UpdatedDate = inputStudentGuardian.CreatedDate;
var invalidStudentGuardianInputException =
new InvalidStudentGuardiantException(
parameterName: nameof(StudentGuardian.CreatedDate),
parameterValue: inputStudentGuardian.CreatedDate);
var expectedStudentGuardianValidationException =
new StudentGuardianValidationException(invalidStudentGuardianInputException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
// when
ValueTask <StudentGuardian> createStudentGuardianTask =
this.studentGuardianService.AddStudentGuardianAsync(inputStudentGuardian);
// then
await Assert.ThrowsAsync <StudentGuardianValidationException>(() =>
createStudentGuardianTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedStudentGuardianValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertStudentGuardianAsync(It.IsAny <StudentGuardian>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnDeleteWhenStorageStudentGuardianIsInvalidAndLogItAsync()
{
// given
DateTimeOffset randomDateTime = GetRandomDateTime();
StudentGuardian randomStudentGuardian = CreateRandomStudentGuardian(randomDateTime);
Guid inputStudentGuardianId = randomStudentGuardian.GuardianId;
Guid inputStudentId = randomStudentGuardian.StudentId;
StudentGuardian nullStorageStudentGuardian = null;
var notFoundStudentGuardianException =
new NotFoundStudentGuardianException(inputStudentGuardianId, inputStudentId);
var expectedStudentGuardianValidationException =
new StudentGuardianValidationException(notFoundStudentGuardianException);
this.storageBrokerMock.Setup(broker =>
broker.SelectStudentGuardianByIdAsync(inputStudentGuardianId, inputStudentId))
.ReturnsAsync(nullStorageStudentGuardian);
// when
ValueTask <StudentGuardian> actualStudentGuardianDeleteTask =
this.studentGuardianService.RemoveStudentGuardianByIdsAsync(inputStudentGuardianId, inputStudentId);
// then
await Assert.ThrowsAsync <StudentGuardianValidationException>(() =>
actualStudentGuardianDeleteTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedStudentGuardianValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectStudentGuardianByIdAsync(inputStudentGuardianId, inputStudentId),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.DeleteStudentGuardianAsync(It.IsAny <StudentGuardian>()),
Times.Never);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenStudentIdIsInvalidAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
StudentGuardian randomStudentGuardian = CreateRandomStudentGuardian(dateTime);
StudentGuardian inputStudentGuardian = randomStudentGuardian;
inputStudentGuardian.StudentId = default;
var invalidStudentGuardianInputException = new InvalidStudentGuardiantException(
parameterName: nameof(StudentGuardian.StudentId),
parameterValue: inputStudentGuardian.StudentId);
var expectedStudentGuardianValidationException =
new StudentGuardianValidationException(invalidStudentGuardianInputException);
// when
ValueTask <StudentGuardian> addStudentGuardianTask =
this.studentGuardianService.AddStudentGuardianAsync(inputStudentGuardian);
// then
await Assert.ThrowsAsync <StudentGuardianValidationException>(() =>
addStudentGuardianTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedStudentGuardianValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertStudentGuardianAsync(It.IsAny <StudentGuardian>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
