public async void ShouldThrowValidationExceptionOnAddWhenTeacherAttachmentIsNullAndLogItAsync()
{
// given
TeacherAttachment invalidTeacherAttachment = null;
var nullTeacherAttachmentException = new NullTeacherAttachmentException();
var expectedTeacherAttachmentValidationException =
new TeacherAttachmentValidationException(nullTeacherAttachmentException);
// when
ValueTask <TeacherAttachment> addTeacherAttachmentTask =
this.teacherAttachmentService.AddTeacherAttachmentAsync(invalidTeacherAttachment);
// then
await Assert.ThrowsAsync <TeacherAttachmentValidationException>(() =>
addTeacherAttachmentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedTeacherAttachmentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertTeacherAttachmentAsync(It.IsAny <TeacherAttachment>()),
Times.Never);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldRetrieveTeacherAttachmentByIdAsync()
{
// given
TeacherAttachment randomTeacherAttachment = CreateRandomTeacherAttachment();
TeacherAttachment storageTeacherAttachment = randomTeacherAttachment;
TeacherAttachment expectedTeacherAttachment = storageTeacherAttachment;
this.storageBrokerMock.Setup(broker =>
broker.SelectTeacherAttachmentByIdAsync
(randomTeacherAttachment.TeacherId, randomTeacherAttachment.AttachmentId))
.ReturnsAsync(storageTeacherAttachment);
// when
TeacherAttachment actualTeacherAttachment = await
this.teacherAttachmentService.RetrieveTeacherAttachmentByIdAsync(
randomTeacherAttachment.TeacherId, randomTeacherAttachment.AttachmentId);
// then
actualTeacherAttachment.Should().BeEquivalentTo(expectedTeacherAttachment);
this.storageBrokerMock.Verify(broker =>
broker.SelectTeacherAttachmentByIdAsync
(randomTeacherAttachment.TeacherId, randomTeacherAttachment.AttachmentId),
Times.Once);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldAddTeacherAttachmentAsync()
{
// given
TeacherAttachment randomTeacherAttachment = CreateRandomTeacherAttachment();
TeacherAttachment inputTeacherAttachment = randomTeacherAttachment;
TeacherAttachment storageTeacherAttachment = randomTeacherAttachment;
TeacherAttachment expectedTeacherAttachment = storageTeacherAttachment;
this.storageBrokerMock.Setup(broker =>
broker.InsertTeacherAttachmentAsync(inputTeacherAttachment))
.ReturnsAsync(storageTeacherAttachment);
// when
TeacherAttachment actualTeacherAttachment =
await this.teacherAttachmentService.AddTeacherAttachmentAsync(inputTeacherAttachment);
// then
actualTeacherAttachment.Should().BeEquivalentTo(expectedTeacherAttachment);
this.storageBrokerMock.Verify(broker =>
broker.InsertTeacherAttachmentAsync(inputTeacherAttachment),
Times.Once);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenAttachmentIdIsInvalidAndLogItAsync()
{
// given
TeacherAttachment randomTeacherAttachment = CreateRandomTeacherAttachment();
TeacherAttachment inputTeacherAttachment = randomTeacherAttachment;
inputTeacherAttachment.AttachmentId = default;
var invalidTeacherAttachmentInputException = new InvalidTeacherAttachmentException(
parameterName: nameof(TeacherAttachment.AttachmentId),
parameterValue: inputTeacherAttachment.AttachmentId);
var expectedTeacherAttachmentValidationException =
new TeacherAttachmentValidationException(invalidTeacherAttachmentInputException);
// when
ValueTask <TeacherAttachment> addTeacherAttachmentTask =
this.teacherAttachmentService.AddTeacherAttachmentAsync(inputTeacherAttachment);
// then
await Assert.ThrowsAsync <TeacherAttachmentValidationException>(() =>
addTeacherAttachmentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedTeacherAttachmentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertTeacherAttachmentAsync(It.IsAny <TeacherAttachment>()),
Times.Never);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
private static void ValidateTeacherAttachmentIsNull(TeacherAttachment teacherContact)
{
if (teacherContact is null)
{
throw new NullTeacherAttachmentException();
}
}
public ValueTask <TeacherAttachment> AddTeacherAttachmentAsync(TeacherAttachment teacherAttachment) =>
TryCatch(async() =>
{
ValidateTeacherAttachmentOnCreate(teacherAttachment);
return(await this.storageBroker.InsertTeacherAttachmentAsync(teacherAttachment));
});
public async Task ShouldThrowServiceExceptionOnAddWhenExceptionOccursAndLogItAsync()
{
// given
TeacherAttachment randomTeacherAttachment = CreateRandomTeacherAttachment();
TeacherAttachment inputTeacherAttachment = randomTeacherAttachment;
var exception = new Exception();
var expectedTeacherAttachmentServiceException = new TeacherAttachmentServiceException(exception);
this.storageBrokerMock.Setup(broker =>
broker.InsertTeacherAttachmentAsync(inputTeacherAttachment))
.ThrowsAsync(exception);
// when
ValueTask <TeacherAttachment> addTeacherAttachmentTask =
this.teacherAttachmentService.AddTeacherAttachmentAsync(inputTeacherAttachment);
// then
await Assert.ThrowsAsync <TeacherAttachmentServiceException>(() =>
addTeacherAttachmentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(expectedTeacherAttachmentServiceException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertTeacherAttachmentAsync(inputTeacherAttachment),
Times.Once);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldGetAllTeacherAttachmentsAsync()
{
// given
var randomTeacherAttachments = new List <TeacherAttachment>();
for (var i = 0; i <= GetRandomNumber(); i++)
{
TeacherAttachment randomTeacherAttachment = await PostTeacherAttachmentAsync();
randomTeacherAttachments.Add(randomTeacherAttachment);
}
List <TeacherAttachment> inputTeacherAttachments = randomTeacherAttachments;
List <TeacherAttachment> expectedTeacherAttachments = inputTeacherAttachments;
// when
List <TeacherAttachment> actualTeacherAttachments =
await this.otripleSApiBroker.GetAllTeacherAttachmentsAsync();
// then
foreach (TeacherAttachment expectedTeacherAttachment in expectedTeacherAttachments)
{
TeacherAttachment actualTeacherAttachment =
actualTeacherAttachments.Single(studentAttachment =>
studentAttachment.TeacherId == expectedTeacherAttachment.TeacherId);
actualTeacherAttachment.Should().BeEquivalentTo(expectedTeacherAttachment);
await DeleteTeacherAttachmentAsync(actualTeacherAttachment);
}
}
public async ValueTask <TeacherAttachment> InsertTeacherAttachmentAsync(
TeacherAttachment teacherAttachment)
{
EntityEntry <TeacherAttachment> teacherAttachmentEntityEntry =
await this.TeacherAttachments.AddAsync(teacherAttachment);
await this.SaveChangesAsync();
return(teacherAttachmentEntityEntry.Entity);
}
public async ValueTask <TeacherAttachment> DeleteTeacherAttachmentAsync(
TeacherAttachment teacherAttachment)
{
EntityEntry <TeacherAttachment> teacherAttachmentEntityEntry =
this.TeacherAttachments.Remove(teacherAttachment);
await this.SaveChangesAsync();
return(teacherAttachmentEntityEntry.Entity);
}
private static void ValidateStorageTeacherAttachment(
TeacherAttachment storageTeacherAttachment,
Guid studentId,
Guid attachmentId)
{
if (storageTeacherAttachment is null)
{
throw new NotFoundTeacherAttachmentException(studentId, attachmentId);
}
}
public ValueTask <TeacherAttachment> RemoveTeacherAttachmentByIdAsync(Guid teacherId, Guid attachmentId) =>
TryCatch(async() =>
{
ValidateTeacherAttachmentIds(teacherId, attachmentId);
TeacherAttachment maybeTeacherAttachment =
await this.storageBroker.SelectTeacherAttachmentByIdAsync(teacherId, attachmentId);
ValidateStorageTeacherAttachment(maybeTeacherAttachment, teacherId, attachmentId);
return(await this.storageBroker.DeleteTeacherAttachmentAsync(maybeTeacherAttachment));
});
public async ValueTask <TeacherAttachment> DeleteTeacherAttachmentAsync(
TeacherAttachment teacherAttachment)
{
using var broker = new StorageBroker(this.configuration);
EntityEntry <TeacherAttachment> teacherAttachmentEntityEntry =
broker.TeacherAttachments.Remove(entity: teacherAttachment);
await broker.SaveChangesAsync();
return(teacherAttachmentEntityEntry.Entity);
}
public async Task ShouldThrowValidationExceptionOnRemoveWhenStorageTeacherAttachmentIsInvalidAndLogItAsync()
{
// given
DateTimeOffset randomDateTime = GetRandomDateTime();
TeacherAttachment randomTeacherAttachment = CreateRandomTeacherAttachment(randomDateTime);
Guid inputAttachmentId = randomTeacherAttachment.AttachmentId;
Guid inputTeacherId = randomTeacherAttachment.TeacherId;
TeacherAttachment nullStorageTeacherAttachment = null;
var notFoundTeacherAttachmentException =
new NotFoundTeacherAttachmentException(inputTeacherId, inputAttachmentId);
var expectedTeacherValidationException =
new TeacherAttachmentValidationException(notFoundTeacherAttachmentException);
this.storageBrokerMock.Setup(broker =>
broker.SelectTeacherAttachmentByIdAsync(inputTeacherId, inputAttachmentId))
.ReturnsAsync(nullStorageTeacherAttachment);
// when
ValueTask <TeacherAttachment> removeTeacherAttachmentTask =
this.teacherAttachmentService.RemoveTeacherAttachmentByIdAsync(inputTeacherId, inputAttachmentId);
// then
await Assert.ThrowsAsync <TeacherAttachmentValidationException>(() =>
removeTeacherAttachmentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedTeacherValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.SelectTeacherAttachmentByIdAsync(It.IsAny <Guid>(), It.IsAny <Guid>()),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.DeleteTeacherAttachmentAsync(It.IsAny <TeacherAttachment>()),
Times.Never);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenTeacherAttachmentAlreadyExistsAndLogItAsync()
{
// given
TeacherAttachment randomTeacherAttachment = CreateRandomTeacherAttachment();
TeacherAttachment alreadyExistsTeacherAttachment = randomTeacherAttachment;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var duplicateKeyException = new DuplicateKeyException(exceptionMessage);
var alreadyExistsTeacherAttachmentException =
new AlreadyExistsTeacherAttachmentException(duplicateKeyException);
var expectedTeacherAttachmentValidationException =
new TeacherAttachmentValidationException(alreadyExistsTeacherAttachmentException);
this.storageBrokerMock.Setup(broker =>
broker.InsertTeacherAttachmentAsync(alreadyExistsTeacherAttachment))
.ThrowsAsync(duplicateKeyException);
// when
ValueTask <TeacherAttachment> addTeacherAttachmentTask =
this.teacherAttachmentService.AddTeacherAttachmentAsync(alreadyExistsTeacherAttachment);
// then
await Assert.ThrowsAsync <TeacherAttachmentValidationException>(() =>
addTeacherAttachmentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedTeacherAttachmentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertTeacherAttachmentAsync(alreadyExistsTeacherAttachment),
Times.Once);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async void ShouldThrowValidationExceptionOnAddWhenReferneceExceptionAndLogItAsync()
{
// given
TeacherAttachment randomTeacherAttachment = CreateRandomTeacherAttachment();
TeacherAttachment invalidTeacherAttachment = randomTeacherAttachment;
string randomMessage = GetRandomMessage();
string exceptionMessage = randomMessage;
var foreignKeyConstraintConflictException = new ForeignKeyConstraintConflictException(exceptionMessage);
var invalidTeacherAttachmentReferenceException =
new InvalidTeacherAttachmentReferenceException(foreignKeyConstraintConflictException);
var expectedTeacherAttachmentValidationException =
new TeacherAttachmentValidationException(invalidTeacherAttachmentReferenceException);
this.storageBrokerMock.Setup(broker =>
broker.InsertTeacherAttachmentAsync(invalidTeacherAttachment))
.ThrowsAsync(foreignKeyConstraintConflictException);
// when
ValueTask <TeacherAttachment> addTeacherAttachmentTask =
this.teacherAttachmentService.AddTeacherAttachmentAsync(invalidTeacherAttachment);
// then
await Assert.ThrowsAsync <TeacherAttachmentValidationException>(() =>
addTeacherAttachmentTask.AsTask());
this.loggingBrokerMock.Verify(broker =>
broker.LogError(It.Is(SameExceptionAs(
expectedTeacherAttachmentValidationException))),
Times.Once);
this.storageBrokerMock.Verify(broker =>
broker.InsertTeacherAttachmentAsync(invalidTeacherAttachment),
Times.Once);
this.storageBrokerMock.VerifyNoOtherCalls();
this.loggingBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
public async Task ShouldPostTeacherAttachmentAsync()
{
// given
TeacherAttachment randomTeacherAttachment = await CreateRandomTeacherAttachment();
TeacherAttachment inputTeacherAttachment = randomTeacherAttachment;
TeacherAttachment expectedTeacherAttachment = inputTeacherAttachment;
// when
TeacherAttachment actualTeacherAttachment =
await this.otripleSApiBroker.PostTeacherAttachmentAsync(inputTeacherAttachment);
TeacherAttachment retrievedTeacherAttachment =
await this.otripleSApiBroker.GetTeacherAttachmentByIdsAsync(
inputTeacherAttachment.TeacherId,
inputTeacherAttachment.AttachmentId);
// then
actualTeacherAttachment.Should().BeEquivalentTo(expectedTeacherAttachment);
retrievedTeacherAttachment.Should().BeEquivalentTo(expectedTeacherAttachment);
await DeleteTeacherAttachmentAsync(actualTeacherAttachment);
}
public async Task ShouldDeleteTeacherAttachmentAsync()
{
// given
TeacherAttachment randomTeacherAttachment = await PostTeacherAttachmentAsync();
TeacherAttachment inputTeacherAttachment = randomTeacherAttachment;
TeacherAttachment expectedTeacherAttachment = inputTeacherAttachment;
// when
TeacherAttachment deletedTeacherAttachment =
await DeleteTeacherAttachmentAsync(inputTeacherAttachment);
ValueTask <TeacherAttachment> getTeacherAttachmentByIdTask =
this.otripleSApiBroker.GetTeacherAttachmentByIdsAsync(
inputTeacherAttachment.TeacherId,
inputTeacherAttachment.AttachmentId);
// then
deletedTeacherAttachment.Should().BeEquivalentTo(expectedTeacherAttachment);
await Assert.ThrowsAsync <HttpResponseNotFoundException>(() =>
getTeacherAttachmentByIdTask.AsTask());
}
private static void ValidateTeacherAttachmentOnCreate(TeacherAttachment teacherAttachment)
{
ValidateTeacherAttachmentIsNull(teacherAttachment);
ValidateTeacherAttachmentIds(teacherAttachment.TeacherId, teacherAttachment.AttachmentId);
}
public async ValueTask <TeacherAttachment> PostTeacherAttachmentAsync(TeacherAttachment teacherAttachment) => await this.apiFactoryClient.PostContentAsync(TeacherAttachmentsRelativeUrl, teacherAttachment);