public async Task ShouldThrowValidationExceptionOnModifyWhenStudentIdIsInvalidAndLogItAsync() { //given Guid invalidStudentId = Guid.Empty; DateTimeOffset dateTime = GetRandomDateTime(); StudentExam randomStudentExam = CreateRandomStudentExam(dateTime); StudentExam invalidStudentExam = randomStudentExam; invalidStudentExam.StudentId = invalidStudentId; var invalidStudentExamException = new InvalidStudentExamException( parameterName: nameof(StudentExam.StudentId), parameterValue: invalidStudentExam.StudentId); var expectedStudentExamValidationException = new StudentExamValidationException(invalidStudentExamException); //when ValueTask <StudentExam> modifyStudentExamTask = this.studentExamService.ModifyStudentExamAsync(invalidStudentExam); //then await Assert.ThrowsAsync <StudentExamValidationException>(() => modifyStudentExamTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedStudentExamValidationException))), Times.Once); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnModifyWhenStudentExamIsNullAndLogItAsync() { //given StudentExam invalidStudentExam = null; var nullStudentExamException = new NullStudentExamException(); var expectedStudentExamValidationException = new StudentExamValidationException(nullStudentExamException); //when ValueTask <StudentExam> modifyStudentExamTask = this.studentExamService.ModifyStudentExamAsync(invalidStudentExam); //then await Assert.ThrowsAsync <StudentExamValidationException>(() => modifyStudentExamTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedStudentExamValidationException))), Times.Once); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnModifyWhenUpdatedDateIsSameAsCreatedDateAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); StudentExam randomStudentExam = CreateRandomStudentExam(dateTime); StudentExam inputStudentExam = randomStudentExam; var invalidStudentExamException = new InvalidStudentExamException( parameterName: nameof(StudentExam.UpdatedDate), parameterValue: inputStudentExam.UpdatedDate); var expectedStudentExamValidationException = new StudentExamValidationException(invalidStudentExamException); // when ValueTask <StudentExam> modifyStudentExamTask = this.studentExamService.ModifyStudentExamAsync(inputStudentExam); // then await Assert.ThrowsAsync <StudentExamValidationException>(() => modifyStudentExamTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedStudentExamValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectStudentExamByIdAsync(It.IsAny <Guid>()), Times.Never); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnAddWhenStudentExamIsNullAndLogItAsync() { // given StudentExam randomStudentExam = default; StudentExam nullStudentExam = randomStudentExam; var nullStudentExamException = new NullStudentExamException(); var expectedStudentExamValidationException = new StudentExamValidationException(nullStudentExamException); // when ValueTask <StudentExam> addStudentExamTask = this.studentExamService.AddStudentExamAsync(nullStudentExam); // then await Assert.ThrowsAsync <StudentExamValidationException>(() => addStudentExamTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedStudentExamValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertStudentExamAsync(It.IsAny <StudentExam>()), Times.Never); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
private StudentExamValidationException CreateAndLogValidationException(Exception exception) { var StudentExamValidationException = new StudentExamValidationException(exception); this.loggingBroker.LogError(StudentExamValidationException); return(StudentExamValidationException); }
public async Task ShouldThrowValidationExceptionOnModifyIfStorageCreatedDateNotSameAsCreateDateAndLogItAsync() { // given int randomNumber = GetRandomNumber(); int randomMinutes = randomNumber; DateTimeOffset randomDate = GetRandomDateTime(); StudentExam randomStudentExam = CreateRandomStudentExam(randomDate); StudentExam invalidStudentExam = randomStudentExam; invalidStudentExam.UpdatedDate = randomDate; StudentExam storageStudentExam = randomStudentExam.DeepClone(); Guid studentId = invalidStudentExam.StudentId; Guid semesterCourseId = invalidStudentExam.ExamId; invalidStudentExam.CreatedDate = storageStudentExam.CreatedDate.AddMinutes(randomNumber); var invalidStudentExamException = new InvalidStudentExamException( parameterName: nameof(StudentExam.CreatedDate), parameterValue: invalidStudentExam.CreatedDate); var expectedStudentExamValidationException = new StudentExamValidationException(invalidStudentExamException); this.storageBrokerMock.Setup(broker => broker.SelectStudentExamByIdAsync(invalidStudentExam.Id)) .ReturnsAsync(storageStudentExam); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(randomDate); // when ValueTask <StudentExam> modifyStudentExamTask = this.studentExamService.ModifyStudentExamAsync(invalidStudentExam); // then await Assert.ThrowsAsync <StudentExamValidationException>(() => modifyStudentExamTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectStudentExamByIdAsync(invalidStudentExam.Id), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedStudentExamValidationException))), Times.Once); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnModifyIfStudentExamDoesntExistAndLogItAsync() { // given int randomNegativeMinutes = GetNegativeRandomNumber(); DateTimeOffset dateTime = GetRandomDateTime(); StudentExam randomStudentExam = CreateRandomStudentExam(dateTime); StudentExam nonExistentStudentExam = randomStudentExam; nonExistentStudentExam.CreatedDate = dateTime.AddMinutes(randomNegativeMinutes); StudentExam noStudentExam = null; var notFoundStudentExamException = new NotFoundStudentExamException(nonExistentStudentExam.Id); var expectedStudentExamValidationException = new StudentExamValidationException(notFoundStudentExamException); this.storageBrokerMock.Setup(broker => broker.SelectStudentExamByIdAsync(nonExistentStudentExam.Id)) .ReturnsAsync(noStudentExam); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(dateTime); // when ValueTask <StudentExam> modifyStudentExamTask = this.studentExamService.ModifyStudentExamAsync(nonExistentStudentExam); // then await Assert.ThrowsAsync <StudentExamValidationException>(() => modifyStudentExamTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectStudentExamByIdAsync(nonExistentStudentExam.Id), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedStudentExamValidationException))), Times.Once); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnDeleteWhenStorageStudentExamIsInvalidAndLogItAsync() { // given DateTimeOffset randomDateTime = GetRandomDateTime(); StudentExam randomStudentExam = CreateRandomStudentExam(randomDateTime); Guid inputStudentExamId = randomStudentExam.Id; StudentExam nullStorageStudentExam = null; var notFoundStudentExamException = new NotFoundStudentExamException(inputStudentExamId); var expectedStudentExamValidationException = new StudentExamValidationException(notFoundStudentExamException); this.storageBrokerMock.Setup(broker => broker.SelectStudentExamByIdAsync(inputStudentExamId)) .ReturnsAsync(nullStorageStudentExam); // when ValueTask <StudentExam> actualStudentExamDeleteTask = this.studentExamService.RemoveStudentExamByIdAsync(inputStudentExamId); // then await Assert.ThrowsAsync <StudentExamValidationException>(() => actualStudentExamDeleteTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedStudentExamValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectStudentExamByIdAsync(inputStudentExamId), Times.Once); this.storageBrokerMock.Verify(broker => broker.DeleteStudentExamAsync(It.IsAny <StudentExam>()), Times.Never); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnRetrieveWhenStorageStudentExamIsNullAndLogItAsync() { // given Guid randomStudentExamId = Guid.NewGuid(); Guid inputStudentExamId = randomStudentExamId; StudentExam invalidStorageStudentExam = null; var notFoundStudentExamException = new NotFoundStudentExamException(inputStudentExamId); var expectedStudentExamValidationException = new StudentExamValidationException(notFoundStudentExamException); this.storageBrokerMock.Setup(broker => broker.SelectStudentExamByIdAsync(inputStudentExamId)) .ReturnsAsync(invalidStorageStudentExam); // when ValueTask <StudentExam> retrieveStudentExamByIdTask = this.studentExamService.RetrieveStudentExamByIdAsync(inputStudentExamId); // then await Assert.ThrowsAsync <StudentExamValidationException>(() => retrieveStudentExamByIdTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedStudentExamValidationException))), Times.Once); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Never); this.storageBrokerMock.Verify(broker => broker.SelectStudentExamByIdAsync(inputStudentExamId), Times.Once); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnRetrieveWhenIdIsInvalidAndLogItAsync() { // given Guid randomStudentExamId = default; Guid inputStudentExamId = randomStudentExamId; var invalidStudentExamException = new InvalidStudentExamException( parameterName: nameof(StudentExam.Id), parameterValue: inputStudentExamId); var expectedStudentExamValidationException = new StudentExamValidationException(invalidStudentExamException); // when ValueTask <StudentExam> retrieveStudentExamByIdTask = this.studentExamService.RetrieveStudentExamByIdAsync(inputStudentExamId); // then await Assert.ThrowsAsync <StudentExamValidationException>(() => retrieveStudentExamByIdTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedStudentExamValidationException))), Times.Once); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Never); this.storageBrokerMock.Verify(broker => broker.SelectStudentExamByIdAsync(It.IsAny <Guid>()), Times.Never); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }