public async Task ShouldThrowDependencyExceptionOnRetrieveByIdWhenDbUpdateConcurrencyExceptionOccursAndLogItAsync() { // given Guid randomClassroomId = Guid.NewGuid(); Guid inputClassroomId = randomClassroomId; var databaseUpdateConcurrencyException = new DbUpdateConcurrencyException(); var lockedClassroomException = new LockedClassroomException(databaseUpdateConcurrencyException); var expectedClassroomDependencyException = new ClassroomDependencyException(lockedClassroomException); this.storageBrokerMock.Setup(broker => broker.SelectClassroomByIdAsync(inputClassroomId)) .ThrowsAsync(databaseUpdateConcurrencyException); //when ValueTask <Classroom> retrieveClassroomTask = this.classroomService.RetrieveClassroomById(inputClassroomId); // then await Assert.ThrowsAsync <ClassroomDependencyException>(() => retrieveClassroomTask.AsTask()); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedClassroomDependencyException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectClassroomByIdAsync(inputClassroomId), Times.Once); this.dateTimeBrokerMock.VerifyNoOtherCalls(); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); }
private async ValueTask <Classroom> TryCatch(ReturningClassroomFunction returningClassroomFunction) { try { return(await returningClassroomFunction()); } catch (NullClassroomException nullClassroomException) { throw CreateAndLogValidationException(nullClassroomException); } catch (InvalidClassroomException invalidClassroomInputException) { throw CreateAndLogValidationException(invalidClassroomInputException); } catch (NotFoundClassroomException notFoundClassroomException) { throw CreateAndLogValidationException(notFoundClassroomException); } catch (SqlException sqlException) { var failedClassroomStorageException = new FailedClassroomStorageException(sqlException); throw CreateAndLogCriticalDependencyException(failedClassroomStorageException); } catch (DuplicateKeyException duplicateKeyException) { var alreadyExistsClassroomException = new AlreadyExistsClassroomException(duplicateKeyException); throw CreateAndLogValidationException(alreadyExistsClassroomException); } catch (DbUpdateConcurrencyException dbUpdateConcurrencyException) { var lockedClassroomException = new LockedClassroomException(dbUpdateConcurrencyException); throw CreateAndLogDependencyValidationException(lockedClassroomException); } catch (DbUpdateException dbUpdateException) { var failedClassroomStorageException = new FailedClassroomStorageException(dbUpdateException); throw CreateAndLogDependencyException(failedClassroomStorageException); } catch (Exception exception) { var failedClassroomServiceException = new FailedClassroomServiceException(exception); throw CreateAndLogServiceException(failedClassroomServiceException); } }
public async Task ShouldThrowDependencyExceptionOnModifyIfDbUpdateConcurrencyExceptionOccursAndLogItAsync() { // given int randomNegativeNumber = GetNegativeRandomNumber(); DateTimeOffset randomDateTime = GetRandomDateTime(); Classroom randomClassroom = CreateRandomClassroom(randomDateTime); Classroom someClassroom = randomClassroom; someClassroom.CreatedDate = randomDateTime.AddMinutes(randomNegativeNumber); var databaseUpdateConcurrencyException = new DbUpdateConcurrencyException(); var lockedClassroomException = new LockedClassroomException(databaseUpdateConcurrencyException); var expectedClassroomDependencyException = new ClassroomDependencyException(lockedClassroomException); this.storageBrokerMock.Setup(broker => broker.SelectClassroomByIdAsync(someClassroom.Id)) .ThrowsAsync(databaseUpdateConcurrencyException); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Returns(randomDateTime); // when ValueTask <Classroom> modifyClassroomTask = this.classroomService.ModifyClassroomAsync(someClassroom); // then await Assert.ThrowsAsync <ClassroomDependencyException>(() => modifyClassroomTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.storageBrokerMock.Verify(broker => broker.SelectClassroomByIdAsync(someClassroom.Id), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs(expectedClassroomDependencyException))), Times.Once); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }
public async Task ShouldThrowDependencyExceptionOnModifyIfDbUpdateConcurrencyExceptionOccursAndLogItAsync() { // given Classroom randomClassroom = CreateRandomClassroom(); var databaseUpdateConcurrencyException = new DbUpdateConcurrencyException(); var lockedClassroomException = new LockedClassroomException(databaseUpdateConcurrencyException); var expectedClassroomDependencyValidationException = new ClassroomDependencyValidationException(lockedClassroomException); this.dateTimeBrokerMock.Setup(broker => broker.GetCurrentDateTime()) .Throws(databaseUpdateConcurrencyException); // when ValueTask <Classroom> modifyClassroomTask = this.classroomService.ModifyClassroomAsync(randomClassroom); // then await Assert.ThrowsAsync <ClassroomDependencyValidationException>(() => modifyClassroomTask.AsTask()); this.dateTimeBrokerMock.Verify(broker => broker.GetCurrentDateTime(), Times.Once); this.loggingBrokerMock.Verify(broker => broker.LogError(It.Is(SameExceptionAs( expectedClassroomDependencyValidationException))), Times.Once); this.storageBrokerMock.Verify(broker => broker.UpdateClassroomAsync(It.IsAny <Classroom>()), Times.Never); this.loggingBrokerMock.VerifyNoOtherCalls(); this.storageBrokerMock.VerifyNoOtherCalls(); this.dateTimeBrokerMock.VerifyNoOtherCalls(); }