public async Task ShouldThrowValidationExceptionOnModifyWhenExamFeeIsNullAndLogItAsync() { //given ExamFee invalidExamFee = null; var nullExamFeeException = new NullExamFeeException(); var expectedExamFeeValidationException = new ExamFeeValidationException(nullExamFeeException); //when ValueTask <ExamFee> modifyExamFeeTask = this.examFeeService.ModifyExamFeeAsync(invalidExamFee); //then await Assert.ThrowsAsync <ExamFeeValidationException>(() => modifyExamFeeTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedExamFeeValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectExamFeeByIdAsync(It.IsAny <Guid>()), Times.Never); this.storageBrokerMock.Verify(broker => broker.UpdateExamFeeAsync(It.IsAny <ExamFee>()), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnAddWhenFeeIdIsInvalidAndLogItAsync() { // given ExamFee randomExamFee = CreateRandomExamFee(); ExamFee inputExamFee = randomExamFee; inputExamFee.FeeId = default; var invalidExamFeeInputException = new InvalidExamFeeException( parameterName: nameof(ExamFee.FeeId), parameterValue: inputExamFee.FeeId); var expectedExamFeeValidationException = new ExamFeeValidationException(invalidExamFeeInputException); // when ValueTask <ExamFee> addExamFeeTask = this.examFeeService.AddExamFeeAsync(inputExamFee); // then await Assert.ThrowsAsync <ExamFeeValidationException>(() => addExamFeeTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedExamFeeValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertExamFeeAsync(It.IsAny <ExamFee>()), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnAddWhenExamFeeIsNullAndLogItAsync() { // given ExamFee randomExamFee = default; ExamFee nullExamFee = randomExamFee; var nullExamFeeException = new NullExamFeeException(); var expectedExamFeeValidationException = new ExamFeeValidationException(nullExamFeeException); // when ValueTask <ExamFee> addExamFeeTask = this.examFeeService.AddExamFeeAsync(nullExamFee); // then await Assert.ThrowsAsync <ExamFeeValidationException>(() => addExamFeeTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedExamFeeValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertExamFeeAsync(It.IsAny <ExamFee>()), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
private ExamFeeValidationException CreateAndLogValidationException(Exception exception) { var ExamFeeValidationException = new ExamFeeValidationException(exception); this.loggingBroker.LogError(ExamFeeValidationException); return(ExamFeeValidationException); }
public async void ShouldThrowValidationExceptionOnCreateWhenAuditFieldsAreInvalidAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); ExamFee randomExamFee = CreateRandomExamFee(dateTime); ExamFee inputExamFee = randomExamFee; inputExamFee.CreatedBy = default; inputExamFee.CreatedDate = default; inputExamFee.UpdatedBy = default; inputExamFee.UpdatedDate = default; var invalidExamFeeInputException = new InvalidExamFeeException(); invalidExamFeeInputException.AddData( key: nameof(ExamFee.CreatedBy), values: "Id is required"); invalidExamFeeInputException.AddData( key: nameof(ExamFee.CreatedDate), values: "Date is required"); invalidExamFeeInputException.AddData( key: nameof(ExamFee.UpdatedBy), values: "Id is required"); invalidExamFeeInputException.AddData( key: nameof(ExamFee.UpdatedDate), values: "Date is required"); var expectedExamFeeValidationException = new ExamFeeValidationException(invalidExamFeeInputException); // when ValueTask <ExamFee> createExamFeeTask = this.examFeeService.AddExamFeeAsync(inputExamFee); // then await Assert.ThrowsAsync <ExamFeeValidationException>(() => createExamFeeTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameValidationExceptionAs( expectedExamFeeValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectExamFeeByIdAsync(It.IsAny <Guid>()), Times.Never); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnModifyIfStorageCreatedByNotSameAsCreatedByAndLogItAsync() { // given int randomNegativeMinutes = GetNegativeRandomNumber(); Guid differentId = Guid.NewGuid(); Guid invalidCreatedBy = differentId; DateTimeOffset randomDate = GetRandomDateTime(); ExamFee randomExamFee = CreateRandomExamFee(randomDate); ExamFee invalidExamFee = randomExamFee; invalidExamFee.CreatedDate = randomDate.AddMinutes(randomNegativeMinutes); ExamFee storageExamFee = randomExamFee.DeepClone(); Guid examFeeId = invalidExamFee.Id; invalidExamFee.CreatedBy = invalidCreatedBy; var invalidExamFeeInputException = new InvalidExamFeeException( parameterName: nameof(ExamFee.CreatedBy), parameterValue: invalidExamFee.CreatedBy); var expectedExamFeeValidationException = new ExamFeeValidationException(invalidExamFeeInputException); this.storageBrokerMock.Setup(broker => broker.SelectExamFeeByIdAsync(examFeeId)) .ReturnsAsync(storageExamFee); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(randomDate); // when ValueTask <ExamFee> modifyExamFeeTask = this.examFeeService.ModifyExamFeeAsync(invalidExamFee); // then await Assert.ThrowsAsync <ExamFeeValidationException>(() => modifyExamFeeTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectExamFeeByIdAsync(invalidExamFee.Id), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedExamFeeValidationException))), Times.Once); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnModifyWhenUpdatedDateIsNotRecentAndLogItAsync( int minutes) { // given DateTimeOffset dateTime = GetRandomDateTime(); ExamFee randomExamFee = CreateRandomExamFee(dateTime); ExamFee inputExamFee = randomExamFee; inputExamFee.UpdatedBy = inputExamFee.CreatedBy; inputExamFee.UpdatedDate = dateTime.AddMinutes(minutes); var invalidExamFeeInputException = new InvalidExamFeeException(); invalidExamFeeInputException.AddData( key: nameof(ExamFee.UpdatedDate), values: $"Date is not recent"); var expectedExamFeeValidationException = new ExamFeeValidationException(invalidExamFeeInputException); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(dateTime); // when ValueTask <ExamFee> modifyExamFeeTask = this.examFeeService.ModifyExamFeeAsync(inputExamFee); // then await Assert.ThrowsAsync <ExamFeeValidationException>(() => modifyExamFeeTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameValidationExceptionAs( expectedExamFeeValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectExamFeeByIdAsync(It.IsAny <Guid>()), Times.Never); this.storageBrokerMock.Verify(broker => broker.UpdateExamFeeAsync(It.IsAny <ExamFee>()), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnAddWhenReferneceExceptionAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); ExamFee randomExamFee = CreateRandomExamFee(dateTime); randomExamFee.UpdatedBy = randomExamFee.CreatedBy; randomExamFee.UpdatedDate = randomExamFee.CreatedDate; ExamFee invalidExamFee = randomExamFee; string randomMessage = GetRandomMessage(); string exceptionMessage = randomMessage; var foreignKeyConstraintConflictException = new ForeignKeyConstraintConflictException(exceptionMessage); var invalidExamFeeReferenceException = new InvalidExamFeeReferenceException(foreignKeyConstraintConflictException); var expectedExamFeeValidationException = new ExamFeeValidationException(invalidExamFeeReferenceException); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(dateTime); this.storageBrokerMock.Setup(broker => broker.InsertExamFeeAsync(invalidExamFee)) .ThrowsAsync(foreignKeyConstraintConflictException); // when ValueTask <ExamFee> addExamFeeTask = this.examFeeService.AddExamFeeAsync(invalidExamFee); // then await Assert.ThrowsAsync <ExamFeeValidationException>(() => addExamFeeTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertExamFeeAsync(invalidExamFee), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedExamFeeValidationException))), Times.Once); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnModifyIfExamFeeDoesntExistAndLogItAsync() { // given int randomNegativeMinutes = GetNegativeRandomNumber(); DateTimeOffset dateTime = GetRandomDateTime(); ExamFee randomExamFee = CreateRandomExamFee(dateTime); ExamFee nonExistentExamFee = randomExamFee; nonExistentExamFee.CreatedDate = dateTime.AddMinutes(randomNegativeMinutes); ExamFee noExamFee = null; var notFoundExamFeeException = new NotFoundExamFeeException(nonExistentExamFee.Id); var expectedExamFeeValidationException = new ExamFeeValidationException(notFoundExamFeeException); this.storageBrokerMock.Setup(broker => broker.SelectExamFeeByIdAsync(nonExistentExamFee.Id)) .ReturnsAsync(noExamFee); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(dateTime); // when ValueTask <ExamFee> modifyExamFeeTask = this.examFeeService.ModifyExamFeeAsync(nonExistentExamFee); // then await Assert.ThrowsAsync <ExamFeeValidationException>(() => modifyExamFeeTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectExamFeeByIdAsync(nonExistentExamFee.Id), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedExamFeeValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.UpdateExamFeeAsync(It.IsAny <ExamFee>()), Times.Never); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnCreateWhenExamFeeAlreadyExistsAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); ExamFee randomExamFee = CreateRandomExamFee(dateTime); ExamFee alreadyExistsExamFee = randomExamFee; alreadyExistsExamFee.UpdatedBy = alreadyExistsExamFee.CreatedBy; string randomMessage = GetRandomMessage(); string exceptionMessage = randomMessage; var duplicateKeyException = new DuplicateKeyException(exceptionMessage); var alreadyExistsExamFeeException = new AlreadyExistsExamFeeException(duplicateKeyException); var expectedExamFeeValidationException = new ExamFeeValidationException(alreadyExistsExamFeeException); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(dateTime); this.storageBrokerMock.Setup(broker => broker.InsertExamFeeAsync(alreadyExistsExamFee)) .ThrowsAsync(duplicateKeyException); // when ValueTask <ExamFee> createExamFeeTask = this.examFeeService.AddExamFeeAsync(alreadyExistsExamFee); // then await Assert.ThrowsAsync <ExamFeeValidationException>(() => createExamFeeTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertExamFeeAsync(alreadyExistsExamFee), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedExamFeeValidationException))), Times.Once); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnAddWhenIdsAreInvalidAndLogItAsync() { // given ExamFee randomExamFee = CreateRandomExamFee(); ExamFee inputExamFee = randomExamFee; inputExamFee.ExamId = default; inputExamFee.FeeId = default; var invalidExamFeeInputException = new InvalidExamFeeException(); invalidExamFeeInputException.AddData( key: nameof(ExamFee.ExamId), values: "Id is required"); invalidExamFeeInputException.AddData( key: nameof(ExamFee.FeeId), values: "Id is required"); var expectedExamFeeValidationException = new ExamFeeValidationException(invalidExamFeeInputException); // when ValueTask <ExamFee> addExamFeeTask = this.examFeeService.AddExamFeeAsync(inputExamFee); // then await Assert.ThrowsAsync <ExamFeeValidationException>(() => addExamFeeTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameValidationExceptionAs( expectedExamFeeValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertExamFeeAsync(It.IsAny <ExamFee>()), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnDeleteWhenStorageExamFeeIsInvalidAndLogItAsync() { // given DateTimeOffset randomDateTime = GetRandomDateTime(); ExamFee randomExamFee = CreateRandomExamFee(randomDateTime); Guid inputExamFeeId = randomExamFee.Id; ExamFee nullStorageExamFee = null; var notFoundExamFeeException = new NotFoundExamFeeException(inputExamFeeId); var expectedExamFeeValidationException = new ExamFeeValidationException(notFoundExamFeeException); this.storageBrokerMock.Setup(broker => broker.SelectExamFeeByIdAsync(inputExamFeeId)) .ReturnsAsync(nullStorageExamFee); // when ValueTask <ExamFee> actualExamFeeDeleteTask = this.examFeeService.RemoveExamFeeByIdAsync(inputExamFeeId); // then await Assert.ThrowsAsync <ExamFeeValidationException>(() => actualExamFeeDeleteTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedExamFeeValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectExamFeeByIdAsync(inputExamFeeId), Times.Once); this.storageBrokerMock.Verify(broker => broker.DeleteExamFeeAsync(It.IsAny <ExamFee>()), Times.Never); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnModifyWhenExamIdIsInvalidAndLogItAsync() { //given Guid invalidExamFeeId = Guid.Empty; DateTimeOffset dateTime = GetRandomDateTime(); ExamFee randomExamFee = CreateRandomExamFee(dateTime); ExamFee invalidExamFee = randomExamFee; invalidExamFee.ExamId = invalidExamFeeId; var invalidExamFeeException = new InvalidExamFeeException( parameterName: nameof(ExamFee.ExamId), parameterValue: invalidExamFee.ExamId); var expectedExamFeeValidationException = new ExamFeeValidationException(invalidExamFeeException); //when ValueTask <ExamFee> modifyExamFeeTask = this.examFeeService.ModifyExamFeeAsync(invalidExamFee); //then await Assert.ThrowsAsync <ExamFeeValidationException>(() => modifyExamFeeTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedExamFeeValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectExamFeeByIdAsync(It.IsAny <Guid>()), Times.Never); this.storageBrokerMock.Verify(broker => broker.UpdateExamFeeAsync(It.IsAny <ExamFee>()), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnRetrieveWhenStorageExamFeeIsNullAndLogItAsync() { // given Guid randomExamFeeId = Guid.NewGuid(); Guid inputExamFeeId = randomExamFeeId; ExamFee invalidStorageExamFee = null; var notFoundExamFeeException = new NotFoundExamFeeException(inputExamFeeId); var expectedExamFeeValidationException = new ExamFeeValidationException(notFoundExamFeeException); this.storageBrokerMock.Setup(broker => broker.SelectExamFeeByIdAsync(inputExamFeeId)) .ReturnsAsync(invalidStorageExamFee); // when ValueTask <ExamFee> retrieveExamFeeByIdTask = this.examFeeService.RetrieveExamFeeByIdAsync(inputExamFeeId); // then await Assert.ThrowsAsync <ExamFeeValidationException>(() => retrieveExamFeeByIdTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedExamFeeValidationException))), Times.Once); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Never); this.storageBrokerMock.Verify(broker => broker.SelectExamFeeByIdAsync(inputExamFeeId), Times.Once); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnRetrieveWhenIdIsInvalidAndLogItAsync() { // given Guid randomExamFeeId = default; Guid inputExamFeeId = randomExamFeeId; var invalidExamFeeInputException = new InvalidExamFeeException( parameterName: nameof(ExamFee.Id), parameterValue: inputExamFeeId); var expectedExamFeeValidationException = new ExamFeeValidationException(invalidExamFeeInputException); // when ValueTask <ExamFee> retrieveExamFeeByIdTask = this.examFeeService.RetrieveExamFeeByIdAsync(inputExamFeeId); // then await Assert.ThrowsAsync <ExamFeeValidationException>(() => retrieveExamFeeByIdTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedExamFeeValidationException))), Times.Once); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Never); this.storageBrokerMock.Verify(broker => broker.SelectExamFeeByIdAsync(It.IsAny <Guid>()), Times.Never); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnCreateWhenUpdatedDateIsNotSameToCreatedDateAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); ExamFee randomExamFee = CreateRandomExamFee(dateTime); ExamFee inputExamFee = randomExamFee; inputExamFee.UpdatedBy = randomExamFee.CreatedBy; inputExamFee.UpdatedDate = GetRandomDateTime(); var invalidExamFeeInputException = new InvalidExamFeeException( parameterName: nameof(ExamFee.UpdatedDate), parameterValue: inputExamFee.UpdatedDate); var expectedExamFeeValidationException = new ExamFeeValidationException(invalidExamFeeInputException); // when ValueTask <ExamFee> createExamFeeTask = this.examFeeService.AddExamFeeAsync(inputExamFee); // then await Assert.ThrowsAsync <ExamFeeValidationException>(() => createExamFeeTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedExamFeeValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectExamFeeByIdAsync(It.IsAny <Guid>()), Times.Never); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }