public async Task ShouldThrowValidationExceptionOnModifyWhenExamFeeIdIsInvalidAndLogItAsync() { //given Guid invalidExamId = Guid.Empty; DateTimeOffset dateTime = GetRandomDateTime(); StudentExamFee randomStudentExamFee = CreateRandomStudentExamFee(dateTime); StudentExamFee invalidStudentExamFee = randomStudentExamFee; invalidStudentExamFee.ExamFeeId = invalidExamId; var invalidStudentExamFeeInputException = new InvalidStudentExamFeeException( parameterName: nameof(StudentExamFee.ExamFeeId), parameterValue: invalidStudentExamFee.ExamFeeId); var expectedStudentExamFeeValidationException = new StudentExamFeeValidationException(invalidStudentExamFeeInputException); //when ValueTask <StudentExamFee> modifyStudentExamFeeTask = this.studentExamFeeService.ModifyStudentExamFeeAsync(invalidStudentExamFee); //then await Assert.ThrowsAsync <StudentExamFeeValidationException>(() => modifyStudentExamFeeTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedStudentExamFeeValidationException))), Times.Once); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnCreateWhenStudentExamFeeIsNullAndLogItAsync() { // given StudentExamFee invalidStudentExamFee = null; var nullStudentExamFeeException = new NullStudentExamFeeException(); var expectedStudentExamFeeValidationException = new StudentExamFeeValidationException(nullStudentExamFeeException); // when ValueTask <StudentExamFee> createStudentExamFeeTask = this.studentExamFeeService.AddStudentExamFeeAsync(invalidStudentExamFee); // then await Assert.ThrowsAsync <StudentExamFeeValidationException>(() => createStudentExamFeeTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedStudentExamFeeValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectStudentExamFeeByIdsAsync( It.IsAny <Guid>(), It.IsAny <Guid>()), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnModifyIfStorageCreatedDateNotSameAsCreateDateAndLogItAsync() { // given int randomNumber = GetRandomNumber(); int randomMinutes = randomNumber; DateTimeOffset randomDate = GetRandomDateTime(); StudentExamFee randomStudentExamFee = CreateRandomStudentExamFee(randomDate); StudentExamFee invalidStudentExamFee = randomStudentExamFee; invalidStudentExamFee.UpdatedDate = randomDate; StudentExamFee storageStudentExamFee = randomStudentExamFee.DeepClone(); Guid studentId = invalidStudentExamFee.StudentId; Guid semesterCourseId = invalidStudentExamFee.ExamFeeId; invalidStudentExamFee.CreatedDate = storageStudentExamFee.CreatedDate.AddMinutes(randomNumber); var invalidStudentExamFeeInputException = new InvalidStudentExamFeeException( parameterName: nameof(StudentExamFee.CreatedDate), parameterValue: invalidStudentExamFee.CreatedDate); var expectedStudentExamFeeValidationException = new StudentExamFeeValidationException(invalidStudentExamFeeInputException); this.storageBrokerMock.Setup(broker => broker.SelectStudentExamFeeByIdsAsync( invalidStudentExamFee.StudentId, invalidStudentExamFee.ExamFeeId)) .ReturnsAsync(storageStudentExamFee); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(randomDate); // when ValueTask <StudentExamFee> modifyStudentExamFeeTask = this.studentExamFeeService.ModifyStudentExamFeeAsync(invalidStudentExamFee); // then await Assert.ThrowsAsync <StudentExamFeeValidationException>(() => modifyStudentExamFeeTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectStudentExamFeeByIdsAsync( invalidStudentExamFee.StudentId, invalidStudentExamFee.ExamFeeId), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedStudentExamFeeValidationException))), Times.Once); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
private StudentExamFeeValidationException CreateAndLogValidationException(Exception exception) { var studentExamFeeValidationException = new StudentExamFeeValidationException(exception); this.loggingBroker.LogError(studentExamFeeValidationException); return(studentExamFeeValidationException); }
public async Task ShouldThrowValidationExceptionOnModifyIfStudentExamFeeDoesnotExistAndLogItAsync() { // given int randomNegativeMinutes = GetNegativeRandomNumber(); DateTimeOffset dateTime = GetRandomDateTime(); StudentExamFee randomStudentExamFee = CreateRandomStudentExamFee(dateTime); StudentExamFee nonExistentStudentExamFee = randomStudentExamFee; nonExistentStudentExamFee.CreatedDate = dateTime.AddMinutes(randomNegativeMinutes); StudentExamFee noStudentExamFee = null; var notFoundStudentExamFeeException = new NotFoundStudentExamFeeException( nonExistentStudentExamFee.StudentId, nonExistentStudentExamFee.ExamFeeId); var expectedStudentExamFeeValidationException = new StudentExamFeeValidationException(notFoundStudentExamFeeException); this.storageBrokerMock.Setup(broker => broker.SelectStudentExamFeeByIdsAsync( nonExistentStudentExamFee.StudentId, nonExistentStudentExamFee.ExamFeeId)) .ReturnsAsync(noStudentExamFee); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(dateTime); // when ValueTask <StudentExamFee> modifyStudentExamFeeTask = this.studentExamFeeService.ModifyStudentExamFeeAsync(nonExistentStudentExamFee); // then await Assert.ThrowsAsync <StudentExamFeeValidationException>(() => modifyStudentExamFeeTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectStudentExamFeeByIdsAsync( nonExistentStudentExamFee.StudentId, nonExistentStudentExamFee.ExamFeeId), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedStudentExamFeeValidationException))), Times.Once); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnCreateWhenStudentExamFeeAlreadyExistsAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); StudentExamFee randomStudentExamFee = CreateRandomStudentExamFee(dateTime); StudentExamFee alreadyExistsStudentExamFee = randomStudentExamFee; alreadyExistsStudentExamFee.UpdatedBy = alreadyExistsStudentExamFee.CreatedBy; string randomMessage = GetRandomMessage(); string exceptionMessage = randomMessage; var duplicateKeyException = new DuplicateKeyException(exceptionMessage); var alreadyExistsStudentExamFeeException = new AlreadyExistsStudentExamFeeException(duplicateKeyException); var expectedExamFeeValidationException = new StudentExamFeeValidationException(alreadyExistsStudentExamFeeException); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(dateTime); this.storageBrokerMock.Setup(broker => broker.InsertStudentExamFeeAsync(alreadyExistsStudentExamFee)) .ThrowsAsync(duplicateKeyException); // when ValueTask <StudentExamFee> createStudentExamFeeTask = this.studentExamFeeService.AddStudentExamFeeAsync(alreadyExistsStudentExamFee); // then await Assert.ThrowsAsync <StudentExamFeeValidationException>(() => createStudentExamFeeTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertStudentExamFeeAsync(alreadyExistsStudentExamFee), 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 ShouldThrowValidationExceptionOnCreateWhenCreatedDateIsNotRecentAndLogItAsync( int minutes) { // given DateTimeOffset dateTime = GetRandomDateTime(); StudentExamFee randomStudentExamFee = CreateRandomStudentExamFee(dateTime); StudentExamFee inputStudentExamFee = randomStudentExamFee; inputStudentExamFee.UpdatedBy = inputStudentExamFee.CreatedBy; inputStudentExamFee.CreatedDate = dateTime.AddMinutes(minutes); inputStudentExamFee.UpdatedDate = inputStudentExamFee.CreatedDate; var invalidStudentExamFeeInputException = new InvalidStudentExamFeeException( parameterName: nameof(StudentExamFee.CreatedDate), parameterValue: inputStudentExamFee.CreatedDate); var expectedStudentExamFeeValidationException = new StudentExamFeeValidationException(invalidStudentExamFeeInputException); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(dateTime); // when ValueTask <StudentExamFee> createStudentExamFeeTask = this.studentExamFeeService.AddStudentExamFeeAsync(inputStudentExamFee); // then await Assert.ThrowsAsync <StudentExamFeeValidationException>(() => createStudentExamFeeTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedStudentExamFeeValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectStudentExamFeeByIdsAsync( It.IsAny <Guid>(), It.IsAny <Guid>()), Times.Never); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnRemoveWhenStorageStudentExamFeeIsInvalidAndLogItAsync() { // given DateTimeOffset randomDateTime = GetRandomDateTime(); StudentExamFee randomStudentExamFee = CreateRandomStudentExamFee(randomDateTime); Guid inputStudentId = randomStudentExamFee.StudentId; Guid inputExamFeeId = randomStudentExamFee.ExamFeeId; StudentExamFee nullStudentExamFees = null; var notFoundStudentExamFeeException = new NotFoundStudentExamFeeException(inputStudentId, inputExamFeeId); var expectedAssignmentValidationException = new StudentExamFeeValidationException(notFoundStudentExamFeeException); this.storageBrokerMock.Setup(broker => broker.SelectStudentExamFeeByIdsAsync( It.IsAny <Guid>(), It.IsAny <Guid>())) .ReturnsAsync(nullStudentExamFees); // when ValueTask <StudentExamFee> removeStudentExamFeeTask = this.studentExamFeeService.RemoveStudentExamFeeByIdAsync( inputStudentId, inputExamFeeId); // then await Assert.ThrowsAsync <StudentExamFeeValidationException>(() => removeStudentExamFeeTask.AsTask()); this.storageBrokerMock.Verify(broker => broker.SelectStudentExamFeeByIdsAsync( It.IsAny <Guid>(), It.IsAny <Guid>()), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedAssignmentValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.DeleteStudentExamFeeAsync(It.IsAny <StudentExamFee>()), Times.Never); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
ShouldThrowValidationExceptionOnRetrieveWhenStorageStudentExamFeeIsNullAndLogItAsync() { // given Guid randomStudentId = Guid.NewGuid(); Guid inputStudentId = randomStudentId; Guid randomExamFeeId = Guid.NewGuid(); Guid inputExamFeeId = randomExamFeeId; StudentExamFee invalidStorageStudentExamFee = null; var notFoundStudentExamFeeException = new NotFoundStudentExamFeeException( inputStudentId, inputExamFeeId); var expectedStudentExamFeeValidationException = new StudentExamFeeValidationException(notFoundStudentExamFeeException); this.storageBrokerMock.Setup(broker => broker.SelectStudentExamFeeByIdsAsync( inputStudentId, inputExamFeeId)) .ReturnsAsync(invalidStorageStudentExamFee); // when ValueTask <StudentExamFee> retrieveStudentExamFeeByIdTask = this.studentExamFeeService.RetrieveStudentExamFeeByIdsAsync( inputStudentId, inputExamFeeId); // then await Assert.ThrowsAsync <StudentExamFeeValidationException>(() => retrieveStudentExamFeeByIdTask.AsTask()); this.storageBrokerMock.Verify(broker => broker.SelectStudentExamFeeByIdsAsync( inputStudentId, inputExamFeeId), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedStudentExamFeeValidationException))), Times.Once); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Never); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidatonExceptionOnRemoveWhenExamFeeIdIsInvalidAndLogItAsync() { // given Guid randomStudentId = Guid.NewGuid(); Guid inputStudentId = randomStudentId; Guid randomExamFeeId = default; Guid inputExamFeeId = randomExamFeeId; var invalidStudentExamFeeInputException = new InvalidStudentExamFeeException( parameterName: nameof(StudentExamFee.ExamFeeId), parameterValue: inputExamFeeId); var expectedStudentExamFeeValidationException = new StudentExamFeeValidationException(invalidStudentExamFeeInputException); // when ValueTask <StudentExamFee> removeStudentExamFeeTask = this.studentExamFeeService.RemoveStudentExamFeeByIdAsync( inputStudentId, inputExamFeeId); // then await Assert.ThrowsAsync <StudentExamFeeValidationException>(() => removeStudentExamFeeTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedStudentExamFeeValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectStudentExamFeeByIdsAsync( It.IsAny <Guid>(), It.IsAny <Guid>()), Times.Never); this.storageBrokerMock.Verify(broker => broker.DeleteStudentExamFeeAsync(It.IsAny <StudentExamFee>()), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnModifyWhenCreatedDateIsInvalidAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); StudentExamFee randomStudentExamFee = CreateRandomStudentExamFee(dateTime); StudentExamFee inputStudentExamFee = randomStudentExamFee; inputStudentExamFee.CreatedDate = default; var invalidStudentExamFeeInputException = new InvalidStudentExamFeeException( parameterName: nameof(StudentExamFee.CreatedDate), parameterValue: inputStudentExamFee.CreatedDate); var expectedStudentExamFeeValidationException = new StudentExamFeeValidationException(invalidStudentExamFeeInputException); // when ValueTask <StudentExamFee> modifyStudentExamFeeTask = this.studentExamFeeService.ModifyStudentExamFeeAsync(inputStudentExamFee); // then await Assert.ThrowsAsync <StudentExamFeeValidationException>(() => modifyStudentExamFeeTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedStudentExamFeeValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectStudentExamFeeByIdsAsync( It.IsAny <Guid>(), It.IsAny <Guid>()), Times.Never); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }