public async Task ShouldThrowValidationExceptionOnModifyWhenCalendarLabelIsInvalidAndLogItAsync(
string invalidCalendarLabel)
{
// given
Calendar randomCalendar = CreateRandomCalendar(DateTime.Now);
Calendar invalidCalendar = randomCalendar;
invalidCalendar.Label = invalidCalendarLabel;
var invalidCalendarException = new InvalidCalendarException(
parameterName: nameof(Calendar.Label),
parameterValue: invalidCalendar.Label);
var expectedCalendarValidationException =
new CalendarValidationException(invalidCalendarException);
// when
ValueTask <Calendar> modifyCalendarTask =
this.calendarService.ModifyCalendarAsync(invalidCalendar);
// then
await Assert.ThrowsAsync <CalendarValidationException>(() =>
modifyCalendarTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedCalendarValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnModifyWhenUpdatedDateIsSameAsCreatedDateAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
Calendar randomCalendar = CreateRandomCalendar(dateTime);
Calendar inputCalendar = randomCalendar;
var invalidCalendarException = new InvalidCalendarException(
parameterName: nameof(Calendar.UpdatedDate),
parameterValue: inputCalendar.UpdatedDate);
var expectedCalendarValidationException =
new CalendarValidationException(invalidCalendarException);
// when
ValueTask <Calendar> modifyCalendarTask =
this.calendarService.ModifyCalendarAsync(inputCalendar);
// then
await Assert.ThrowsAsync <CalendarValidationException>(() =>
modifyCalendarTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedCalendarValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectCalendarByIdAsync(It.IsAny <Guid>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnModifyIfStorageCreatedByNotSameAsCreatedByAndLogItAsync()
{
// given
int randomNegativeMinutes = GetNegativeRandomNumber();
Guid differentId = Guid.NewGuid();
Guid invalidCreatedBy = differentId;
DateTimeOffset randomDate = GetRandomDateTime();
Calendar randomCalendar = CreateRandomCalendar(randomDate);
Calendar invalidCalendar = randomCalendar;
invalidCalendar.CreatedDate = randomDate.AddMinutes(randomNegativeMinutes);
Calendar storageCalendar = randomCalendar.DeepClone();
Guid calendarId = invalidCalendar.Id;
invalidCalendar.CreatedBy = invalidCreatedBy;
var invalidCalendarException = new InvalidCalendarException(
parameterName: nameof(Calendar.CreatedBy),
parameterValue: invalidCalendar.CreatedBy);
var expectedCalendarValidationException =
new CalendarValidationException(invalidCalendarException);
this.storageBrokerMock.Setup(broker =>
broker.SelectCalendarByIdAsync(calendarId))
.ReturnsAsync(storageCalendar);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(randomDate);
// when
ValueTask <Calendar> modifyCalendarTask =
this.calendarService.ModifyCalendarAsync(invalidCalendar);
// then
await Assert.ThrowsAsync <CalendarValidationException>(() =>
modifyCalendarTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectCalendarByIdAsync(invalidCalendar.Id),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedCalendarValidationException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenCreatedDateIsNotRecentAndLogItAsync(
int minutes)
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
Calendar randomCalendar = CreateRandomCalendar(dateTime);
Calendar inputCalendar = randomCalendar;
inputCalendar.UpdatedBy = inputCalendar.CreatedBy;
inputCalendar.CreatedDate = dateTime.AddMinutes(minutes);
inputCalendar.UpdatedDate = inputCalendar.CreatedDate;
var invalidCalendarException = new InvalidCalendarException(
parameterName: nameof(Calendar.CreatedDate),
parameterValue: inputCalendar.CreatedDate);
var expectedCalendarValidationException =
new CalendarValidationException(invalidCalendarException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
// when
ValueTask <Calendar> registerCalendarTask =
this.calendarService.AddCalendarAsync(inputCalendar);
// then
await Assert.ThrowsAsync <CalendarValidationException>(() =>
registerCalendarTask.AsTask());
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedCalendarValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertCalendarAsync(It.IsAny <Calendar>()),
Times.Never);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidatonExceptionOnDeleteWhenIdIsInvalidAndLogItAsync()
{
// given
Guid invalidCalendarId = Guid.Empty;
var invalidCalendarException = new InvalidCalendarException(
parameterName: nameof(Calendar.Id),
parameterValue: invalidCalendarId);
var expectedCalendarValidationException =
new CalendarValidationException(invalidCalendarException);
// when
ValueTask <Calendar> deleteCalendarTask =
this.calendarService.RemoveCalendarByIdAsync(invalidCalendarId);
// then
await Assert.ThrowsAsync <CalendarValidationException>(() => deleteCalendarTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedCalendarValidationException))),
Times.Once);
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Never);
this.storageBrokerMock.Verify(broker =>
broker.SelectCalendarByIdAsync(It.IsAny <Guid>()),
Times.Never);
this.storageBrokerMock.Verify(broker =>
broker.DeleteCalendarAsync(It.IsAny <Calendar>()),
Times.Never);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowValidationExceptionOnAddWhenLabelIsInvalidAndLogItAsync(
string invalidCalendarLabel)
{
// given
DateTimeOffset datetime = DateTimeOffset.UtcNow;
Calendar randomCalendar = CreateRandomCalendar(dates: datetime);
Calendar invalidCalendar = randomCalendar;
invalidCalendar.Label = invalidCalendarLabel;
var invalidCalendarException = new InvalidCalendarException(
parameterName: nameof(Calendar.Label),
parameterValue: invalidCalendar.Label);
var expectedCalendarValidationException =
new CalendarValidationException(invalidCalendarException);
// when
ValueTask <Calendar> registerCalendarTask =
this.calendarService.AddCalendarAsync(invalidCalendar);
// then
await Assert.ThrowsAsync <CalendarValidationException>(() =>
registerCalendarTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedCalendarValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertCalendarAsync(It.IsAny <Calendar>()),
Times.Never);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
