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 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 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 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 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 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 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 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 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();
}
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();
}
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 InvalidStudentEventArgs(InvalidStudentException studentException) => StudentException = studentException;
