public async Task ShouldThrowValidationExceptionOnModifyWhenStudentUserIdIsInvalidAndLogItAsync(
string invalidStudentUserId)
{
// given
Student randomStudent = CreateRandomStudent();
Student invalidStudent = randomStudent;
invalidStudent.UserId = invalidStudentUserId;
var invalidStudentException = new InvalidStudentException(
parameterName: nameof(Student.UserId),
parameterValue: invalidStudent.UserId);
var expectedStudentValidationException =
new StudentValidationException(invalidStudentException);
// when
ValueTask <Student> modifyStudentTask =
this.studentService.ModifyStudentAsync(invalidStudent);
// then
await Assert.ThrowsAsync <StudentValidationException>(() =>
modifyStudentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnRegisterIfStudentIsNullAndLogItAsync()
{
// given
Student invalidStudent = null;
var nullStudentException = new NullStudentException();
var expectedStudentValidationException =
new StudentValidationException(nullStudentException);
// when
ValueTask <Student> submitStudentTask =
this.studentService.RegisterStudentAsync(invalidStudent);
// then
await Assert.ThrowsAsync <StudentValidationException>(() =>
submitStudentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(
It.Is(SameExceptionAs(expectedStudentValidationException))),
Times.Once);
this.apiBrokerMock.Verify(broker =>
broker.PostStudentAsync(It.IsAny <Student>()),
Times.Never);
this.apiBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
public async Task ThrowValidationExceptionOnDeleteIfIdIsInvalidAndLogItAsync()
{
// given
Guid invalidId = default;
Student randomStudent = CreateRandomStudent();
Student storageStudent = randomStudent;
Student expectedStudent = storageStudent;
var studentValidationException =
new InvalidStudentException(nameof(Student.Id), parameterValue: invalidId);
var expectedStudentValidationException =
new StudentValidationException(studentValidationException);
//when
ValueTask <Student> deleteStudentTask =
this.studentService.DeleteStudentAsync(invalidId);
//then
await Assert.ThrowsAsync <StudentValidationException>(() => deleteStudentTask.AsTask());
this.storageBrokerMock.Verify(broker =>
broker.SelectStudentByIdAsync(It.IsAny <Guid>()), Times.Never);
this.storageBrokerMock.Verify(broker =>
broker.DeleteStudentAsync(It.IsAny <Student>()), Times.Never);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentValidationException))),
Times.Once);
}
public async Task ShouldThrowValidationExceptionOnRegisterIfStudentAlreadyExistsAndLogItAsync()
{
// given
Student randomStudent = CreateRandomStudent();
Student inputStudent = randomStudent;
Student storageStudent = inputStudent;
string someMessage = new MnemonicString().GetValue();
var duplicateKeyException = new DuplicateKeyException(someMessage);
var alreadyExistsStudentException = new AlreadyExistsStudentException(duplicateKeyException);
var expectedStudentValidationException = new StudentValidationException(alreadyExistsStudentException);
this.storageBrokerMock.Setup(broker =>
broker.InsertStudentAsync(inputStudent))
.ThrowsAsync(duplicateKeyException);
// when
ValueTask <Student> submitStudentTask =
this.studentService.RegisterStudentAsync(inputStudent);
// then
await Assert.ThrowsAsync <StudentValidationException>(() => submitStudentTask.AsTask());
this.storageBrokerMock.Verify(broker =>
broker.InsertStudentAsync(inputStudent),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentValidationException))),
Times.Once);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
private StudentValidationException CreateAndLogValidationException(Exception exception)
{
var studentValidationException = new StudentValidationException(exception);
this.loggingBroker.LogError(studentValidationException);
return studentValidationException;
}
public async Task ShouldThrowValidationExceptionOnModifyIfStudentIsNullAndLogItAsync()
{
//given
Student noStudent = null;
var nullStudentException = new NullStudentException();
var expectedStudentValidationException =
new StudentValidationException(nullStudentException);
//when
ValueTask <Student> modifyStudentTask = this.studentService.ModifyStudentAsync(noStudent);
//then
await Assert.ThrowsAsync <StudentValidationException>(() => modifyStudentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectStudentByIdAsync(It.IsAny <Guid>()),
Times.Never);
this.storageBrokerMock.Verify(broker =>
broker.UpdateStudentAsync(It.IsAny <Student>()),
Times.Never);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnRegisterIfStudentIdIsInvalidAndLogItAsync()
{
//given
Guid invalidId = Guid.Empty;
Student randomStudent = CreateRandomStudent();
Student invalidStudent = randomStudent;
invalidStudent.Id = invalidId;
var invalidStudentException = new InvalidStudentException(parameterName: nameof(Student.Id), parameterValue: invalidStudent.Id);
var expectedStudentValidationException = new StudentValidationException(invalidStudentException);
//when
ValueTask <Student> registerStudentTask = this.studentService.RegisterStudentAsync(invalidStudent);
//then
await Assert.ThrowsAsync <StudentValidationException>(() =>
registerStudentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentValidationException))),
Times.Once);
this.apiBrokerMock.Verify(broker =>
broker.PostStudentAsync(It.IsAny <Student>()),
Times.Never);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.apiBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnRegisterWhenStudentIsNullAndLogItAsync()
{
// given
Student randomStudent = null;
Student nullStudent = randomStudent;
var nullStudentException = new NullStudentException();
var expectedStudentValidationException =
new StudentValidationException(nullStudentException);
// when
ValueTask <Student> registerStudentTask =
this.studentService.RegisterStudentAsync(nullStudent);
// then
await Assert.ThrowsAsync <StudentValidationException>(() =>
registerStudentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertStudentAsync(It.IsAny <Student>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnRetrieveIfStudentWasNotFoundAndLogItAsync()
{
// given
Student noStudent = null;
Guid nonExistentStudentId = Guid.NewGuid();
var notFoundStudentException =
new NotFoundStudentException(studentId: nonExistentStudentId);
var expectedStudentValidationException =
new StudentValidationException(notFoundStudentException);
this.storageBrokerMock.Setup(broker =>
broker.SelectStudentByIdAsync(nonExistentStudentId))
.ReturnsAsync(noStudent);
// when
ValueTask <Student> retrieveStudentByIdTask =
this.studentService.RetrieveStudentAsync(nonExistentStudentId);
// then
await Assert.ThrowsAsync <StudentValidationException>(() =>
retrieveStudentByIdTask.AsTask());
this.storageBrokerMock.Verify(broker =>
broker.SelectStudentByIdAsync(nonExistentStudentId),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentValidationException))),
Times.Once);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnRetrieveIfIdWasInvalidAndLogItAsync()
{
// given
Guid invalidId = Guid.Empty;
var invalidStudentException = new InvalidStudentException(
parameterName: nameof(Student.Id),
parameterValue: invalidId);
var expectedStudentValidationException =
new StudentValidationException(invalidStudentException);
// when
ValueTask <Student> retrieveStudentByIdTask =
this.studentService.RetrieveStudentAsync(invalidId);
// then
await Assert.ThrowsAsync <StudentValidationException>(() => retrieveStudentByIdTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectStudentByIdAsync(It.IsAny <Guid>()),
Times.Never);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnModifyIfStorageUpdatedDateSameAsUpdatedDateAndLogItAsync()
{
// given
int randomNegativeMinutes = GetNegativeRandomNumber();
int minutesInThePast = randomNegativeMinutes;
DateTimeOffset randomDate = GetRandomDateTime();
Student randomStudent = CreateRandomStudent(dates: randomDate);
randomStudent.CreatedDate = randomStudent.CreatedDate.AddMinutes(minutesInThePast);
Student invalidStudent = randomStudent;
invalidStudent.UpdatedDate = randomDate;
Student storageStudent = randomStudent.DeepClone();
Guid studentId = invalidStudent.Id;
var invalidStudentException = new InvalidStudentException(
parameterName: nameof(Student.UpdatedDate),
parameterValue: invalidStudent.UpdatedDate);
var expectedStudentValidationException =
new StudentValidationException(invalidStudentException);
this.storageBrokerMock.Setup(broker =>
broker.SelectStudentByIdAsync(studentId))
.ReturnsAsync(storageStudent);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(randomDate);
// when
ValueTask <Student> modifyStudentTask =
this.studentService.ModifyStudentAsync(invalidStudent);
// then
await Assert.ThrowsAsync <StudentValidationException>(() =>
modifyStudentTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectStudentByIdAsync(invalidStudent.Id),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnModifyIfStorageCreatedByNotSameAsCreatedByAndLogItAsync()
{
// given
Guid differentId = Guid.NewGuid();
Guid invalidCreatedBy = differentId;
DateTimeOffset randomDate = GetRandomDateTime();
Student randomStudent = CreateRandomStudent();
Student invalidStudent = randomStudent;
invalidStudent.UpdatedDate = randomDate;
Student storageStudent = randomStudent.DeepClone();
Guid studentId = invalidStudent.Id;
invalidStudent.CreatedBy = invalidCreatedBy;
var invalidStudentException = new InvalidStudentException(
parameterName: nameof(Student.CreatedBy),
parameterValue: invalidStudent.CreatedBy);
var expectedStudentValidationException =
new StudentValidationException(invalidStudentException);
this.storageBrokerMock.Setup(broker =>
broker.SelectStudentByIdAsync(studentId))
.ReturnsAsync(storageStudent);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(randomDate);
// when
ValueTask <Student> modifyStudentTask =
this.studentService.ModifyStudentAsync(invalidStudent);
// then
await Assert.ThrowsAsync <StudentValidationException>(() =>
modifyStudentTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectStudentByIdAsync(invalidStudent.Id),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnRegisterWhenStudentAlreadyExistsAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
Student randomStudent = CreateRandomStudent(dateTime);
Student alreadyExistsStudent = randomStudent;
alreadyExistsStudent.UpdatedBy = alreadyExistsStudent.CreatedBy;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var duplicateKeyException = new DuplicateKeyException(exceptionMessage);
var alreadyExistsStudentException =
new AlreadyExistsStudentException(duplicateKeyException);
var expectedStudentValidationException =
new StudentValidationException(alreadyExistsStudentException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
this.storageBrokerMock.Setup(broker =>
broker.InsertStudentAsync(alreadyExistsStudent))
.ThrowsAsync(duplicateKeyException);
// when
ValueTask <Student> registerStudentTask =
this.studentService.RegisterStudentAsync(alreadyExistsStudent);
// then
await Assert.ThrowsAsync <StudentValidationException>(() =>
registerStudentTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertStudentAsync(alreadyExistsStudent),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentValidationException))),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnRegisterWhenCreatedDateIsNotRecentAndLogItAsync(
int minutes)
{
// given
DateTimeOffset randomDate = GetRandomDateTime();
Student randomStudent = CreateRandomStudent(randomDate);
Student invalidStudent = randomStudent;
invalidStudent.CreatedDate = randomDate.AddMinutes(minutes);
invalidStudent.UpdatedDate = invalidStudent.CreatedDate;
var invalidStudentException = new InvalidStudentException();
invalidStudentException.AddData(
key: nameof(Student.CreatedDate),
values: $"Date is not recent");
var expectedStudentValidationException =
new StudentValidationException(invalidStudentException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(randomDate);
// when
ValueTask <Student> registerStudentTask =
this.studentService.RegisterStudentAsync(invalidStudent);
// then
await Assert.ThrowsAsync <StudentValidationException>(() =>
registerStudentTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameValidationExceptionAs(
expectedStudentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertStudentAsync(It.IsAny <Student>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnModifyIfStudentDoesntExistAndLogItAsync()
{
DateTimeOffset randomDateTime = GetRandomDateTime();
Student randomStudent = CreateRandomStudent();
Student nonExistentStudent = randomStudent;
nonExistentStudent.UpdatedDate = randomDateTime;
Student noStudent = null;
var notFoundStudentException = new NotFoundStudentException(nonExistentStudent.Id);
var expectedStudentValidationException =
new StudentValidationException(notFoundStudentException);
this.storageBrokerMock.Setup(broker =>
broker.SelectStudentByIdAsync(nonExistentStudent.Id))
.ReturnsAsync(noStudent);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(randomDateTime);
// when
ValueTask <Student> modifyStudentTask =
this.studentService.ModifyStudentAsync(nonExistentStudent);
// then
await Assert.ThrowsAsync <StudentValidationException>(() =>
modifyStudentTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectStudentByIdAsync(nonExistentStudent.Id),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedStudentValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnDeleteWhenStorageStudentIsNullAndLogItAsync()
{
// given
Guid randomStudentId = Guid.NewGuid();
Guid inputStudentId = randomStudentId;
Student invalidStorageStudent = null;
var notFoundStudentException = new NotFoundStudentException(inputStudentId);
var expectedStudentValidationException =
new StudentValidationException(notFoundStudentException);
this.storageBrokerMock.Setup(broker =>
broker.SelectStudentByIdAsync(inputStudentId))
.ReturnsAsync(invalidStorageStudent);
// when
ValueTask <Student> deleteStudentTask =
this.studentService.RemoveStudentByIdAsync(inputStudentId);
// then
await Assert.ThrowsAsync <StudentValidationException>(() =>
deleteStudentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedStudentValidationException))),
Times.Once);
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Never);
this.storageBrokerMock.Verify(broker =>
broker.SelectStudentByIdAsync(inputStudentId),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.DeleteStudentAsync(It.IsAny <Student>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnModifyIfCreatedAndUpdatedDatesAreSameAndLogItAsync()
{
// given
Student randomStudent = CreateRandomStudent();
DateTimeOffset sameDate = randomStudent.CreatedDate;
Student invalidStudent = randomStudent;
invalidStudent.CreatedDate = sameDate;
invalidStudent.UpdatedDate = sameDate;
var invalidStudentException = new InvalidStudentException();
invalidStudentException.AddData(
key: nameof(Student.UpdatedDate),
values: $"Date is the same as {nameof(Student.CreatedDate)}");
var expectedStudentValidationException =
new StudentValidationException(invalidStudentException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(DateTimeOffset.UtcNow);
// when
ValueTask <Student> modifyStudentTask =
this.studentService.ModifyStudentAsync(invalidStudent);
// then
await Assert.ThrowsAsync <StudentValidationException>(() =>
modifyStudentTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameValidationExceptionAs(
expectedStudentValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnModifyIfStudentUpdatedDateIsNotRecentAndLogItAsync(
int randomMoreOrLessThanOneMinute)
{
// given
DateTimeOffset randomDateTime = GetRandomDateTime();
Student randomStudent = CreateRandomStudent(dates: randomDateTime);
Student invalidStudent = randomStudent;
invalidStudent.UpdatedDate =
invalidStudent.UpdatedDate.AddMinutes(randomMoreOrLessThanOneMinute);
var invalidStudentException = new InvalidStudentException(
parameterName: nameof(Student.UpdatedDate),
parameterValue: invalidStudent.UpdatedDate);
var expectedStudentValidationException =
new StudentValidationException(invalidStudentException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(randomDateTime);
// when
ValueTask <Student> modifyStudentTask =
this.studentService.ModifyStudentAsync(invalidStudent);
// then
await Assert.ThrowsAsync <StudentValidationException>(() =>
modifyStudentTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnModifyIfStudentIdIsInvalidAndLogItAsync()
{
//given
Student randomStudent = CreateRandomStudent();
Guid invalidStudentId = Guid.Empty;
Student invalidStudent = randomStudent;
invalidStudent.Id = invalidStudentId;
IEnumerable <ValidationFailure> validationFailures =
studentValidator.ShouldHaveValidationErrorFor(student =>
student.Id, invalidStudent);
var validationException = new ValidationException(validationFailures);
var expectedStudentValidationException =
new StudentValidationException(validationException);
//when
ValueTask <Student> modifyStudentTask =
this.studentService.ModifyStudentAsync(invalidStudent);
//then
await Assert.ThrowsAsync <StudentValidationException>(() =>
modifyStudentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectStudentByIdAsync(It.IsAny <Guid>()),
Times.Never);
this.storageBrokerMock.Verify(broker =>
broker.UpdateStudentAsync(It.IsAny <Student>()),
Times.Never);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnDeleteWhenIdIsInvalidAndLogItAsync()
{
// given
Guid randomStudentId = default;
Guid inputStudentId = randomStudentId;
var invalidStudentException = new InvalidStudentException(
parameterName: nameof(Student.Id),
parameterValue: inputStudentId);
var expectedStudentValidationException =
new StudentValidationException(invalidStudentException);
// when
ValueTask <Student> deleteStudentTask =
this.studentService.RemoveStudentByIdAsync(inputStudentId);
// then
await Assert.ThrowsAsync <StudentValidationException>(() =>
deleteStudentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedStudentValidationException))),
Times.Once);
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Never);
this.storageBrokerMock.Verify(broker =>
broker.DeleteStudentAsync(It.IsAny <Student>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnRegisterWhenUpdatedDateIsNotSameToCreatedDateAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
Student randomStudent = CreateRandomStudent(dateTime);
Student inputStudent = randomStudent;
inputStudent.UpdatedBy = randomStudent.CreatedBy;
inputStudent.UpdatedDate = GetRandomDateTime();
var invalidStudentInputException = new InvalidStudentException(
parameterName: nameof(Student.UpdatedDate),
parameterValue: inputStudent.UpdatedDate);
var expectedStudentValidationException =
new StudentValidationException(invalidStudentInputException);
// when
ValueTask <Student> registerStudentTask =
this.studentService.RegisterStudentAsync(inputStudent);
// then
await Assert.ThrowsAsync <StudentValidationException>(() =>
registerStudentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertStudentAsync(It.IsAny <Student>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnRegisterIfStudentNameWasInvalidAndLogItAsync()
{
// given
Student randomStudent = CreateRandomStudent();
Student invalidStudent = randomStudent;
string invalidName = string.Empty;
invalidStudent.Name = invalidName;
IEnumerable <ValidationFailure> validationFailures =
studentValidator.ShouldHaveValidationErrorFor(student =>
student.Name, invalidStudent);
var validationException = new ValidationException(validationFailures);
var expectedStudentValidationException =
new StudentValidationException(validationException);
// when
ValueTask <Student> registerStudentTask =
this.studentService.RegisterStudentAsync(invalidStudent);
// then
await Assert.ThrowsAsync <StudentValidationException>(() =>
registerStudentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertStudentAsync(It.IsAny <Student>()),
Times.Never);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnRegisterWhenStudentFirstNameIsInvalidAndLogItAsync(
string invalidStudentFirstName)
{
// given
Student randomStudent = CreateRandomStudent();
Student invalidStudent = randomStudent;
invalidStudent.FirstName = invalidStudentFirstName;
var invalidStudentException = new InvalidStudentException(
parameterName: nameof(Student.FirstName),
parameterValue: invalidStudent.FirstName);
var expectedStudentValidationException =
new StudentValidationException(invalidStudentException);
// when
ValueTask <Student> registerStudentTask =
this.studentService.RegisterStudentAsync(invalidStudent);
// then
await Assert.ThrowsAsync <StudentValidationException>(() =>
registerStudentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertStudentAsync(It.IsAny <Student>()),
Times.Never);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
ShouldThrowValidationExceptionOnModifyIfStorageStudentAuditInformationNotSameAsInputStudentAuditInformationAndLogItAsync()
{
// given
int randomNumber = GetRandomNumber();
DateTimeOffset randomDate = GetRandomDateTime();
Guid differentId = Guid.NewGuid();
Guid invalidCreatedBy = differentId;
Student randomStudent = CreateRandomStudent(dates: randomDate);
Student invalidStudent = randomStudent;
Student storageStudent = randomStudent.DeepClone();
invalidStudent.CreatedDate = storageStudent.CreatedDate.AddDays(randomNumber);
invalidStudent.UpdatedDate = storageStudent.UpdatedDate;
invalidStudent.CreatedBy = invalidCreatedBy;
Guid studentId = invalidStudent.Id;
var invalidStudentException = new InvalidStudentException();
invalidStudentException.AddData(
key: nameof(Student.CreatedDate),
values: $"Date is not the same as {nameof(Student.CreatedDate)}");
invalidStudentException.AddData(
key: nameof(Student.UpdatedDate),
values: $"Date is same as {nameof(Student.UpdatedDate)}");
invalidStudentException.AddData(
key: nameof(Student.CreatedBy),
values: $"Id is not the same as {nameof(Student.CreatedBy)}");
var expectedStudentValidationException =
new StudentValidationException(invalidStudentException);
this.storageBrokerMock.Setup(broker =>
broker.SelectStudentByIdAsync(studentId))
.ReturnsAsync(storageStudent);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(randomDate);
// when
ValueTask <Student> modifyStudentTask =
this.studentService.ModifyStudentAsync(invalidStudent);
// then
await Assert.ThrowsAsync <StudentValidationException>(() =>
modifyStudentTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectStudentByIdAsync(invalidStudent.Id),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedStudentValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnModifyWhenStudentIsInvalidAndLogItAsync(string invalidText)
{
// given
var invalidStudent = new Student
{
UserId = invalidText,
IdentityNumber = invalidText,
FirstName = invalidText,
};
var invalidStudentException = new InvalidStudentException();
invalidStudentException.AddData(
key: nameof(Student.Id),
values: "Id is required");
invalidStudentException.AddData(
key: nameof(Student.UserId),
values: "Text is required");
invalidStudentException.AddData(
key: nameof(Student.IdentityNumber),
values: "Text is required");
invalidStudentException.AddData(
key: nameof(Student.FirstName),
values: "Text is required");
invalidStudentException.AddData(
key: nameof(Student.BirthDate),
values: "Date is required");
invalidStudentException.AddData(
key: nameof(Student.CreatedBy),
values: "Id is required");
invalidStudentException.AddData(
key: nameof(Student.UpdatedBy),
values: "Id is required");
invalidStudentException.AddData(
key: nameof(Student.CreatedDate),
values: "Date is required");
invalidStudentException.AddData(
key: nameof(Student.UpdatedDate),
"Date is required",
$"Date is the same as {nameof(Student.CreatedDate)}");
var expectedStudentValidationException =
new StudentValidationException(invalidStudentException);
// when
ValueTask <Student> modifyStudentTask =
this.studentService.ModifyStudentAsync(invalidStudent);
// then
await Assert.ThrowsAsync <StudentValidationException>(() =>
modifyStudentTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameValidationExceptionAs(expectedStudentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.UpdateStudentAsync(It.IsAny <Student>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
