public async Task ShouldThrowDependencyExceptionOnRetrieveByIdWhenDbExceptionOccursAndLogItAsync()
{
// given
Guid someTagId = Guid.NewGuid();
var databaseUpdateException = new DbUpdateException();
var expectedTagDependencyException =
new TagDependencyException(databaseUpdateException);
this.storageBrokerMock.Setup(broker =>
broker.SelectTagByIdAsync(It.IsAny <Guid>()))
.ThrowsAsync(databaseUpdateException);
// when
ValueTask <Tag> retrieveByIdTagTask =
this.tagService.RetrieveTagByIdAsync(someTagId);
// then
await Assert.ThrowsAsync <TagDependencyException>(() =>
retrieveByIdTagTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedTagDependencyException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectTagByIdAsync(It.IsAny <Guid>()),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowDependencyExceptionOnRetrieveByIdWhenSqlExceptionOccursAndLogItAsync()
{
// given
Guid randomTagId = Guid.NewGuid();
Guid inputTagId = randomTagId;
SqlException sqlException = GetSqlException();
var exceptionTagDependencyException =
new TagDependencyException(sqlException);
this.storageBrokerMock.Setup(broker =>
broker.SelectTagByIdAsync(inputTagId))
.ThrowsAsync(sqlException);
// when
ValueTask <Tag> retrieveTagByIdTask =
this.tagService.RetrieveTagByIdAsync(inputTagId);
// then
await Assert.ThrowsAsync <TagDependencyException>(() =>
retrieveTagByIdTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogCritical(It.Is(SameExceptionAs(exceptionTagDependencyException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectTagByIdAsync(inputTagId),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public void ShouldThrowDependencyExceptionOnRetrieveAllTagsWhenSqlExceptionOccursAndLogIt()
{
// given
var sqlException = GetSqlException();
var expectedTagDependencyException =
new TagDependencyException(sqlException);
this.storageBrokerMock.Setup(broker =>
broker.SelectAllTags())
.Throws(sqlException);
// when . then
Assert.Throws <TagDependencyException>(() =>
this.tagService.RetrieveAllTags());
this.storageBrokerMock.Verify(broker =>
broker.SelectAllTags(),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogCritical(It.Is(SameExceptionAs(expectedTagDependencyException))),
Times.Once);
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
private TagDependencyException CreateAndLogCriticalDependencyException(Exception exception)
{
var categoryDependencyException = new TagDependencyException(exception);
this.loggingBroker.LogCritical(categoryDependencyException);
return(categoryDependencyException);
}
private TagDependencyException CreateAndLogDependencyException(Exception exception)
{
var tagDependencyException = new TagDependencyException(exception);
this.loggingBroker.LogError(tagDependencyException);
return(tagDependencyException);
}
public async Task ShouldThrowDependencyExceptionOnAddWhenDbExceptionOccursAndLogItAsync()
{
// given
DateTimeOffset dateTime = GetRandomDateTime();
Tag randomTag = CreateRandomTag(dateTime);
Tag inputTag = randomTag;
inputTag.UpdatedBy = inputTag.CreatedBy;
var databaseUpdateException = new DbUpdateException();
var expectedTagDependencyException =
new TagDependencyException(databaseUpdateException);
this.dateTimeBrokerMock.Setup(broker =>
broker.GetCurrentDateTime())
.Returns(dateTime);
this.storageBrokerMock.Setup(broker =>
broker.InsertTagAsync(inputTag))
.ThrowsAsync(databaseUpdateException);
// when
ValueTask <Tag> createTagTask =
this.tagService.AddTagAsync(inputTag);
// then
await Assert.ThrowsAsync <TagDependencyException>(() =>
createTagTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedTagDependencyException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertTagAsync(inputTag),
Times.Once);
this.dateTimeBrokerMock.Verify(broker =>
broker.GetCurrentDateTime(),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowDependencyExceptionOnModifyIfDbUpdateExceptionOccursAndLogItAsync()
{
// given
int randomNegativeNumber = GetNegativeRandomNumber();
DateTimeOffset randomDateTime = GetRandomDateTime();
Tag someTag = CreateRandomTag(randomDateTime);
someTag.CreatedDate = randomDateTime.AddMinutes(randomNegativeNumber);
var databaseUpdateException = new DbUpdateException();
var expectedTagDependencyException =
new TagDependencyException(databaseUpdateException);
this.storageBrokerMock.Setup(broker =>
broker.SelectTagByIdAsync(someTag.Id))
.ThrowsAsync(databaseUpdateException);
//this.dateTimeBrokerMock.Setup(broker =>
// broker.GetCurrentDateTime())
// .Returns(randomDateTime);
// when
ValueTask <Tag> modifyTagTask =
this.tagService.ModifyTagAsync(someTag);
// then
await Assert.ThrowsAsync <TagDependencyException>(() =>
modifyTagTask.AsTask());
//this.dateTimeBrokerMock.Verify(broker =>
// broker.GetCurrentDateTime(),
// Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectTagByIdAsync(someTag.Id),
Times.Once);
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedTagDependencyException))),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldThrowDependencyExceptionOnDeleteWhenDbUpdateConcurrencyExceptionOccursAndLogItAsync()
{
// given
Guid randomTagId = Guid.NewGuid();
Guid inputTagId = randomTagId;
var databaseUpdateConcurrencyException = new DbUpdateConcurrencyException();
var lockedTagException =
new LockedTagException(databaseUpdateConcurrencyException);
var expectedTagException =
new TagDependencyException(lockedTagException);
this.storageBrokerMock.Setup(broker =>
broker.SelectTagByIdAsync(inputTagId))
.ThrowsAsync(databaseUpdateConcurrencyException);
// when
ValueTask <Tag> deleteTagTask =
this.tagService.RemoveTagByIdAsync(inputTagId);
// then
await Assert.ThrowsAsync <TagDependencyException>(() => deleteTagTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedTagException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectTagByIdAsync(inputTagId),
Times.Once);
this.dateTimeBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.storageBrokerMock.VerifyNoOtherCalls();
}
