public async Task ShouldThrowValidationExceptionOnModifyWhenExamIsNullAndLogItAsync() { //given Exam invalidExam = null; var nullExamException = new NullExamException(); var expectedExamValidationException = new ExamValidationException(nullExamException); //when ValueTask <Exam> modifyExamTask = this.examService.ModifyExamAsync(invalidExam); //then await Assert.ThrowsAsync <ExamValidationException>(() => modifyExamTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedExamValidationException))), Times.Once); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnAddWhenExamIsNullAndLogItAsync() { // given Exam randomExam = default; Exam nullExam = randomExam; var nullExamException = new NullExamException(); var expectedExamValidationException = new ExamValidationException(nullExamException); // when ValueTask <Exam> createExamTask = this.examService.AddExamAsync(nullExam); // then await Assert.ThrowsAsync <ExamValidationException>(() => createExamTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedExamValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertExamAsync(It.IsAny <Exam>()), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnModifyWhenUpdatedDateIsSameAsCreatedDateAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); Exam randomExam = CreateRandomExam(dateTime); Exam inputExam = randomExam; var invalidExamInputException = new InvalidExamInputException( parameterName: nameof(Exam.UpdatedDate), parameterValue: inputExam.UpdatedDate); var expectedExamValidationException = new ExamValidationException(invalidExamInputException); // when ValueTask <Exam> modifyExamTask = this.examService.ModifyExamAsync(inputExam); // then await Assert.ThrowsAsync <ExamValidationException>(() => modifyExamTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedExamValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectExamByIdAsync(It.IsAny <Guid>()), Times.Never); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnModifyWhenExamIdIsInvalidAndLogItAsync() { //given Guid invalidExamId = Guid.Empty; DateTimeOffset dateTime = GetRandomDateTime(); Exam randomExam = CreateRandomExam(dateTime); Exam invalidExam = randomExam; invalidExam.Id = invalidExamId; var invalidExamException = new InvalidExamInputException( parameterName: nameof(Exam.Id), parameterValue: invalidExam.Id); var expectedExamValidationException = new ExamValidationException(invalidExamException); //when ValueTask <Exam> modifyExamTask = this.examService.ModifyExamAsync(invalidExam); //then await Assert.ThrowsAsync <ExamValidationException>(() => modifyExamTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedExamValidationException))), Times.Once); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
private ExamValidationException CreateAndLogValidationException(Exception exception) { var examValidationException = new ExamValidationException(exception); this.loggingBroker.LogError(examValidationException); return(examValidationException); }
public async Task ShouldThrowValidationExceptionOnModifyWhenExamIsInvalidAndLogItAsyn() { // given var invalidExam = new Exam(); var invalidExamException = new InvalidExamException(); invalidExamException.AddData( key: nameof(Exam.Id), values: "Id is required"); invalidExamException.AddData( key: nameof(Exam.CreatedBy), values: "Id is required"); invalidExamException.AddData( key: nameof(Exam.CreatedDate), values: "Date is required"); invalidExamException.AddData( key: nameof(Exam.UpdatedBy), values: "Id is required"); invalidExamException.UpsertDataList( key: nameof(Exam.UpdatedDate), value: "Date is required"); invalidExamException.UpsertDataList( key: nameof(Exam.UpdatedDate), value: $"Date is same as {nameof(Exam.CreatedDate)}"); var expectedExamValidationException = new ExamValidationException(invalidExamException); // when ValueTask <Exam> modifyExamTask = this.examService.ModifyExamAsync(invalidExam); // then await Assert.ThrowsAsync <ExamValidationException>(() => modifyExamTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameValidationExceptionAs( expectedExamValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectExamByIdAsync(It.IsAny <Guid>()), Times.Never); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnModifyIfStorageUpdatedDateSameAsUpdatedDateAndLogItAsync() { // given int randomNegativeMinutes = GetNegativeRandomNumber(); int minutesInThePast = randomNegativeMinutes; DateTimeOffset randomDate = GetRandomDateTime(); Exam randomExam = CreateRandomExam(randomDate); randomExam.CreatedDate = randomExam.CreatedDate.AddMinutes(minutesInThePast); Exam invalidExam = randomExam; invalidExam.UpdatedDate = randomDate; Exam storageExam = randomExam.DeepClone(); Guid ExamId = invalidExam.Id; var invalidExamException = new InvalidExamException(); invalidExamException.AddData( key: nameof(Exam.UpdatedDate), values: $"Date is same as {nameof(Exam.UpdatedDate)}"); var expectedExamValidationException = new ExamValidationException(invalidExamException); this.storageBrokerMock.Setup(broker => broker.SelectExamByIdAsync(ExamId)) .ReturnsAsync(storageExam); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(randomDate); // when ValueTask <Exam> modifyExamTask = this.examService.ModifyExamAsync(invalidExam); // then await Assert.ThrowsAsync <ExamValidationException>(() => modifyExamTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectExamByIdAsync(invalidExam.Id), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameValidationExceptionAs( expectedExamValidationException))), Times.Once); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnModifyIfStorageCreatedByNotSameAsCreatedByAndLogItAsync() { // given int randomNegativeMinutes = GetNegativeRandomNumber(); Guid differentId = Guid.NewGuid(); Guid invalidCreatedBy = differentId; DateTimeOffset randomDate = GetRandomDateTime(); Exam randomExam = CreateRandomExam(randomDate); Exam invalidExam = randomExam; invalidExam.CreatedDate = randomDate.AddMinutes(randomNegativeMinutes); Exam storageExam = randomExam.DeepClone(); Guid ExamId = invalidExam.Id; invalidExam.CreatedBy = invalidCreatedBy; var invalidExamInputException = new InvalidExamInputException( parameterName: nameof(Exam.CreatedBy), parameterValue: invalidExam.CreatedBy); var expectedExamValidationException = new ExamValidationException(invalidExamInputException); this.storageBrokerMock.Setup(broker => broker.SelectExamByIdAsync(ExamId)) .ReturnsAsync(storageExam); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(randomDate); // when ValueTask <Exam> modifyExamTask = this.examService.ModifyExamAsync(invalidExam); // then await Assert.ThrowsAsync <ExamValidationException>(() => modifyExamTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectExamByIdAsync(invalidExam.Id), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedExamValidationException))), Times.Once); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnAddIfExamIsInvalidAndLogItAsync() { // given var invalidExam = new Exam(); var invalidExamException = new InvalidExamException(); invalidExamException.AddData( key: nameof(Exam.Id), values: "Id is required"); invalidExamException.AddData( key: nameof(Exam.CreatedBy), values: "Id is required"); invalidExamException.AddData( key: nameof(Exam.CreatedDate), values: "Date is required"); invalidExamException.AddData( key: nameof(Exam.UpdatedBy), values: "Id is required"); invalidExamException.AddData( key: nameof(Exam.UpdatedDate), values: "Date is required"); var expectedExamValidationException = new ExamValidationException(invalidExamException); // when ValueTask <Exam> createExamTask = this.examService.AddExamAsync(invalidExam); // then await Assert.ThrowsAsync <ExamValidationException>(() => createExamTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedExamValidationException))), Times.Once); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertExamAsync(It.IsAny <Exam>()), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnAddWhenExamAlreadyExistsAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); Exam randomExam = CreateRandomExam(dateTime); Exam alreadyExistsExam = randomExam; alreadyExistsExam.UpdatedBy = alreadyExistsExam.CreatedBy; string randomMessage = GetRandomMessage(); string exceptionMessage = randomMessage; var duplicateKeyException = new DuplicateKeyException(exceptionMessage); var alreadyExistsExamException = new AlreadyExistsExamException(duplicateKeyException); var expectedExamValidationException = new ExamValidationException(alreadyExistsExamException); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(dateTime); this.storageBrokerMock.Setup(broker => broker.InsertExamAsync(alreadyExistsExam)) .ThrowsAsync(duplicateKeyException); // when ValueTask <Exam> createExamTask = this.examService.AddExamAsync(alreadyExistsExam); // then await Assert.ThrowsAsync <ExamValidationException>(() => createExamTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedExamValidationException))), Times.Once); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertExamAsync(alreadyExistsExam), Times.Once); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnAddWhenCreatedDateIsNotRecentAndLogItAsync( int minutes) { // given DateTimeOffset dateTime = GetRandomDateTime(); Exam randomExam = CreateRandomExam(dateTime); Exam inputExam = randomExam; inputExam.UpdatedBy = inputExam.CreatedBy; inputExam.CreatedDate = dateTime.AddMinutes(minutes); inputExam.UpdatedDate = inputExam.CreatedDate; var invalidExamException = new InvalidExamException(); invalidExamException.AddData( key: nameof(Exam.CreatedDate), values: "Date is not recent"); var expectedExamValidationException = new ExamValidationException(invalidExamException); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(dateTime); // when ValueTask <Exam> createExamTask = this.examService.AddExamAsync(inputExam); // then await Assert.ThrowsAsync <ExamValidationException>(() => createExamTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameValidationExceptionAs( expectedExamValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertExamAsync(It.IsAny <Exam>()), Times.Never); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidationExceptionOnModifyIfExamDoesntExistAndLogItAsync() { // given int randomNegativeMinutes = GetNegativeRandomNumber(); DateTimeOffset dateTime = GetRandomDateTime(); Exam randomExam = CreateRandomExam(dateTime); Exam nonExistentExam = randomExam; nonExistentExam.CreatedDate = dateTime.AddMinutes(randomNegativeMinutes); Exam noExam = null; var notFoundExamException = new NotFoundExamException(nonExistentExam.Id); var expectedExamValidationException = new ExamValidationException(notFoundExamException); this.storageBrokerMock.Setup(broker => broker.SelectExamByIdAsync(nonExistentExam.Id)) .ReturnsAsync(noExam); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(dateTime); // when ValueTask <Exam> modifyExamTask = this.examService.ModifyExamAsync(nonExistentExam); // then await Assert.ThrowsAsync <ExamValidationException>(() => modifyExamTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectExamByIdAsync(nonExistentExam.Id), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedExamValidationException))), Times.Once); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnAddWhenUpdatedByIsNotSameToCreatedByAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); Exam randomExam = CreateRandomExam(dateTime); Exam inputExam = randomExam; inputExam.UpdatedBy = Guid.NewGuid(); var invalidExamException = new InvalidExamException(); invalidExamException.AddData( key: nameof(Exam.UpdatedBy), values: $"Id is not same as {nameof(Exam.CreatedBy)}"); var expectedExamValidationException = new ExamValidationException(invalidExamException); // when ValueTask <Exam> createExamTask = this.examService.AddExamAsync(inputExam); // then await Assert.ThrowsAsync <ExamValidationException>(() => createExamTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameValidationExceptionAs( expectedExamValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertExamAsync(It.IsAny <Exam>()), Times.Never); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnModifyWhenExamTypeIsInvalidAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); Exam randomExam = CreateRandomExam(dateTime); var invalidExam = randomExam; invalidExam.Type = GetInValidExamType(); var invalidExamException = new InvalidExamException(); invalidExamException.AddData( key: nameof(Exam.Type), values: "Value is invalid"); var expectedExamValidationException = new ExamValidationException(invalidExamException); // when ValueTask <Exam> modifyExamTask = this.examService.ModifyExamAsync(invalidExam); // then await Assert.ThrowsAsync <ExamValidationException>(() => modifyExamTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameValidationExceptionAs( expectedExamValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectExamByIdAsync(It.IsAny <Guid>()), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidatonExceptionOnDeleteIfStorageExamIsInvalidAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); Exam randomExam = CreateRandomExam(dateTime); Guid inputExamId = randomExam.Id; Exam inputExam = randomExam; Exam nullStorageExam = null; var notFoundExamException = new NotFoundExamException(inputExamId); var expectedExamValidationException = new ExamValidationException(notFoundExamException); this.storageBrokerMock.Setup(broker => broker.SelectExamByIdAsync(inputExamId)) .ReturnsAsync(nullStorageExam); // when ValueTask <Exam> actualExamTask = this.examService.RemoveExamByIdAsync(inputExamId); // then await Assert.ThrowsAsync <ExamValidationException>(() => actualExamTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedExamValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectExamByIdAsync(inputExamId), Times.Once); this.storageBrokerMock.Verify(broker => broker.DeleteExamAsync(It.IsAny <Exam>()), Times.Never); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnRetrieveByIdIfStorageExamIsNullAndLogItAsync() { // given Guid someExamId = Guid.NewGuid(); Exam invalidStorageExam = null; var notFoundExamException = new NotFoundExamException(someExamId); var expectedExamValidationException = new ExamValidationException(notFoundExamException); this.storageBrokerMock.Setup(broker => broker.SelectExamByIdAsync(someExamId)) .ReturnsAsync(invalidStorageExam); // when ValueTask <Exam> retrieveExamByIdTask = this.examService.RetrieveExamByIdAsync(someExamId); // then await Assert.ThrowsAsync <ExamValidationException>(() => retrieveExamByIdTask.AsTask()); this.storageBrokerMock.Verify(broker => broker.SelectExamByIdAsync(someExamId), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedExamValidationException))), Times.Once); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Never); this.storageBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnRetrieveByIdWhenIdIsInvalidAndLogItAsync() { // given Guid randomExamId = default; Guid inputExamId = randomExamId; var invalidExamInputException = new InvalidExamException(); invalidExamInputException.AddData( key: nameof(Exam.Id), values: "Id is required"); var expectedExamValidationException = new ExamValidationException(invalidExamInputException); // when ValueTask <Exam> retrieveExamByIdTask = this.examService.RetrieveExamByIdAsync(inputExamId); // then await Assert.ThrowsAsync <ExamValidationException>(() => retrieveExamByIdTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameValidationExceptionAs( expectedExamValidationException))), Times.Once); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Never); this.storageBrokerMock.Verify(broker => broker.SelectExamByIdAsync(It.IsAny <Guid>()), Times.Never); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowValidatonExceptionOnDeleteIfIdIsInvalidAndLogItAsync() { // given Guid randomExamId = Guid.Empty; Guid inputExamId = randomExamId; var invalidExamInputException = new InvalidExamException(); invalidExamInputException.AddData( key: nameof(Exam.Id), values: "Id is required"); var expectedExamValidationException = new ExamValidationException(invalidExamInputException); // when ValueTask <Exam> actualExamTask = this.examService.RemoveExamByIdAsync(inputExamId); // then await Assert.ThrowsAsync <ExamValidationException>(() => actualExamTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedExamValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectExamByIdAsync(It.IsAny <Guid>()), Times.Never); this.storageBrokerMock.Verify(broker => broker.DeleteExamAsync(It.IsAny <Exam>()), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async void ShouldThrowValidationExceptionOnAddWhenCreatedByIsInvalidAndLogItAsync() { // given DateTimeOffset dateTime = GetRandomDateTime(); Exam randomExam = CreateRandomExam(dateTime); Exam inputExam = randomExam; inputExam.CreatedBy = default; var invalidExamInputException = new InvalidExamInputException( parameterName: nameof(Exam.CreatedBy), parameterValue: inputExam.CreatedBy); var expectedExamValidationException = new ExamValidationException(invalidExamInputException); // when ValueTask <Exam> createExamTask = this.examService.AddExamAsync(inputExam); // then await Assert.ThrowsAsync <ExamValidationException>(() => createExamTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedExamValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.InsertExamAsync(It.IsAny <Exam>()), Times.Never); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }