public void ShouldReturnValueOfCorrectType() { var mockUnitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); var mockAsyncRepository = new Mock <IAsyncRepository <IDbModel> >(); IEnumerable <Type> repositoryQueryResult = new List <Type>(); mockAsyncRepository.Setup( repo => repo.GetAll( It.IsAny <Expression <Func <IDbModel, bool> > >(), It.IsAny <Expression <Func <IDbModel, int> > >(), It.IsAny <Expression <Func <IDbModel, Type> > >(), It.IsAny <int>(), It.IsAny <int>())) .Returns(() => Task.Run(() => repositoryQueryResult)); var genericAsyncService = new GenericAsyncService <IDbModel>(mockAsyncRepository.Object, mockUnitOfWorkFactory.Object); Expression <Func <IDbModel, bool> > filter = (IDbModel model) => model.Id > 0; Expression <Func <IDbModel, int> > orderBy = (IDbModel model) => model.Id; Expression <Func <IDbModel, Type> > select = (IDbModel model) => model.GetType(); var actualResult = genericAsyncService.GetAll(filter, orderBy, select); Assert.That(actualResult, Is.InstanceOf <IEnumerable <Type> >()); }
public void ShouldReturnTheResultOfTheRepositoryTask() { var mockUnitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); var mockAsyncRepository = new Mock <IAsyncRepository <IDbModel> >(); IEnumerable <IDbModel> repositoryQueryResult = new List <IDbModel>(); mockAsyncRepository.Setup( repo => repo.GetAll( It.IsAny <Expression <Func <IDbModel, bool> > >(), It.IsAny <Expression <Func <IDbModel, int> > >(), It.IsAny <int>(), It.IsAny <int>())) .Returns(() => Task.Run(() => repositoryQueryResult)); var genericAsyncService = new GenericAsyncService <IDbModel>(mockAsyncRepository.Object, mockUnitOfWorkFactory.Object); var page = 0; var pageSize = 5; Expression <Func <IDbModel, bool> > filter = (IDbModel model) => model.Id > 0; Expression <Func <IDbModel, int> > orderBy = (IDbModel model) => model.Id; var actualResult = genericAsyncService.GetAll(filter, orderBy, page, pageSize); Assert.That(actualResult, Is.SameAs(repositoryQueryResult)); }
public void CreatesAValidIGenericAsyncServiceInstance_WhenConstructorParametersAreValid() { var mockAsyncRepository = new Mock <IAsyncRepository <IDbModel> >(); var mockUnitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); var actualGenericAsyncServiceInstance = new GenericAsyncService <IDbModel>(mockAsyncRepository.Object, mockUnitOfWorkFactory.Object); Assert.That(actualGenericAsyncServiceInstance, Is.Not.Null.And.InstanceOf <Contracts.IGenericAsyncService <IDbModel> >()); }
public void ShouldInvokeAsyncRepository_CorrectGetAllWithCorrectFilterExpression() { var mockAsyncRepository = new Mock <IAsyncRepository <IDbModel> >(); var mockUnitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); var genericAsyncService = new GenericAsyncService <IDbModel>(mockAsyncRepository.Object, mockUnitOfWorkFactory.Object); genericAsyncService.GetDeleted(); mockAsyncRepository.Verify(repo => repo.GetAll((x) => x.IsDeleted), Times.Once); }
public void ShouldInvokeAsyncRepository_CorrectGetAllOnce() { var mockAsyncRepository = new Mock <IAsyncRepository <IDbModel> >(); var mockUnitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); var genericAsyncService = new GenericAsyncService <IDbModel>(mockAsyncRepository.Object, mockUnitOfWorkFactory.Object); genericAsyncService.GetDeleted(); mockAsyncRepository.Verify(repo => repo.GetAll(It.IsAny <Expression <Func <IDbModel, bool> > >()), Times.Once); }
public void ShouldInvokeAsyncRepository_CorrectGetAllWithCorrectFilterExpression() { var mockAsyncRepository = new Mock <IAsyncRepository <IDbModel> >(); var mockUnitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); var genericAsyncService = new GenericAsyncService <IDbModel>(mockAsyncRepository.Object, mockUnitOfWorkFactory.Object); Expression <Func <IDbModel, bool> > filter = (IDbModel model) => model.Id > 0; genericAsyncService.GetAll(filter); mockAsyncRepository.Verify(repo => repo.GetAll(filter), Times.Once); }
public void ShouldThrowArgumentNullException_WhenItemParameterIsNull() { var asyncRepository = new Mock <IAsyncRepository <IDbModel> >(); var unitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); var genericAsyncService = new GenericAsyncService <IDbModel>(asyncRepository.Object, unitOfWorkFactory.Object); IDbModel invalidItem = null; Assert.That( () => genericAsyncService.Delete(invalidItem), Throws.InstanceOf <ArgumentNullException>().With.Message.Contains("Invalid item to delete!")); }
public void ShouldThrowArgumentNullExceptionWithCorrectMessage_WhenFilterParameterIsNull() { var mockAsyncRepository = new Mock <IAsyncRepository <IDbModel> >(); var mockUnitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); var genericAsyncService = new GenericAsyncService <IDbModel>(mockAsyncRepository.Object, mockUnitOfWorkFactory.Object); Expression <Func <IDbModel, bool> > filter = null; Assert.That( () => genericAsyncService.GetAll(filter), Throws.InstanceOf <ArgumentNullException>().With.Message.Contains(nameof(filter))); }
public void ShouldReturnTheResultOfTheRepositoryTask() { var mockUnitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); var mockAsyncRepository = new Mock <IAsyncRepository <IDbModel> >(); IEnumerable <IDbModel> repositoryQueryResult = new List <IDbModel>(); mockAsyncRepository.Setup(repo => repo.GetAll(It.IsAny <Expression <Func <IDbModel, bool> > >())).Returns(() => Task.Run(() => repositoryQueryResult)); var genericAsyncService = new GenericAsyncService <IDbModel>(mockAsyncRepository.Object, mockUnitOfWorkFactory.Object); var actualResult = genericAsyncService.GetDeleted(); Assert.That(actualResult, Is.SameAs(repositoryQueryResult)); }
public void ShouldInvokeAsyncRepository_CorrectGetAllOnce() { var mockAsyncRepository = new Mock <IAsyncRepository <IDbModel> >(); var mockUnitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); var genericAsyncService = new GenericAsyncService <IDbModel>(mockAsyncRepository.Object, mockUnitOfWorkFactory.Object); Expression <Func <IDbModel, bool> > filter = (IDbModel model) => model.Id > 0; Expression <Func <IDbModel, int> > orderBy = (IDbModel model) => model.Id; genericAsyncService.GetAll(filter, orderBy); mockAsyncRepository.Verify(repo => repo.GetAll(It.IsAny <Expression <Func <IDbModel, bool> > >(), It.IsAny <Expression <Func <IDbModel, int> > >()), Times.Once); }
public void AssignsCorrectValueToUnitOfWorkFactoryField_WhenParametersAreCorrect() { var mockAsyncRepository = new Mock <IAsyncRepository <IDbModel> >(); var mockUnitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); var genericAsyncServiceInstance = new GenericAsyncService <IDbModel>(mockAsyncRepository.Object, mockUnitOfWorkFactory.Object); var fieldName = "unitOfWorkFactory"; var bindingFlags = BindingFlags.NonPublic | BindingFlags.Instance; var asyncRepositoryField = genericAsyncServiceInstance.GetType().GetField(fieldName, bindingFlags); var asyncRepositoryFieldValue = asyncRepositoryField.GetValue(genericAsyncServiceInstance); Assert.That(asyncRepositoryFieldValue, Is.EqualTo(mockUnitOfWorkFactory.Object)); }
public void ShouldThrowArgumentExceptionWithCorrectMessage_WhenPageSizeParameterIsNegative() { var mockAsyncRepository = new Mock <IAsyncRepository <IDbModel> >(); var mockUnitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); var genericAsyncService = new GenericAsyncService <IDbModel>(mockAsyncRepository.Object, mockUnitOfWorkFactory.Object); var page = 1000; var pageSize = -5; Expression <Func <IDbModel, bool> > filter = (IDbModel model) => model.Id > 0; Assert.That( () => genericAsyncService.GetAll(filter, page, pageSize), Throws.InstanceOf <ArgumentException>().With.Message.Contains("Page Size value must be greater than or equal to 0.")); }
public void ShouldInvokeAsyncRepository_CorrectGetAllWithCorrectPageSizeValue() { var mockAsyncRepository = new Mock <IAsyncRepository <IDbModel> >(); var mockUnitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); var genericAsyncService = new GenericAsyncService <IDbModel>(mockAsyncRepository.Object, mockUnitOfWorkFactory.Object); var page = 0; var pageSize = 5; Expression <Func <IDbModel, bool> > filter = (IDbModel model) => model.Id > 0; genericAsyncService.GetAll(filter, page, pageSize); mockAsyncRepository.Verify(repo => repo.GetAll(It.IsAny <Expression <Func <IDbModel, bool> > >(), It.IsAny <int>(), pageSize), Times.Once); }
public void ShouldThrowArgumentNullExceptionWithCorrectMessage_WhenOrderByParameterIsNull() { var mockAsyncRepository = new Mock <IAsyncRepository <IDbModel> >(); var mockUnitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); var genericAsyncService = new GenericAsyncService <IDbModel>(mockAsyncRepository.Object, mockUnitOfWorkFactory.Object); Expression <Func <IDbModel, bool> > filter = (IDbModel model) => model.Id > 0; Expression <Func <IDbModel, int> > orderBy = null; Expression <Func <IDbModel, Type> > select = (IDbModel model) => model.GetType(); Assert.That( () => genericAsyncService.GetAll(filter, orderBy, select), Throws.InstanceOf <ArgumentNullException>().With.Message.Contains(nameof(orderBy))); }
public void ShouldInvokeAsyncRepository_GetAllAsyncMethodOnce() { var mockAsyncRepository = new Mock <IAsyncRepository <IDbModel> >(); var mockUnitOfWork = new Mock <IDisposableUnitOfWork>(); var mockUnitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); mockUnitOfWorkFactory.Setup(factory => factory.CreateUnitOfWork()).Returns(mockUnitOfWork.Object); var genericAsyncService = new GenericAsyncService <IDbModel>(mockAsyncRepository.Object, mockUnitOfWorkFactory.Object); genericAsyncService.GetAll(); mockAsyncRepository.Verify(repo => repo.GetAllAsync(), Times.Once); }
public void ShouldReturnTheCorrectItem_WhenParametersAreCorrect() { var mockAsyncRepository = new Mock <IAsyncRepository <IDbModel> >(); var mockUnitOfWork = new Mock <IDisposableUnitOfWork>(); var mockUnitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); mockUnitOfWorkFactory.Setup(factory => factory.CreateUnitOfWork()).Returns(mockUnitOfWork.Object); var genericAsyncService = new GenericAsyncService <IDbModel>(mockAsyncRepository.Object, mockUnitOfWorkFactory.Object); var validItem = new Mock <IDbModel>(); var actualResult = genericAsyncService.Update(validItem.Object); Assert.That(actualResult, Is.SameAs(validItem.Object)); }
public void ShouldInvokeAsyncRepositoryAddMethodWithCorrectItem_WhenParametersAreCorrect() { var mockAsyncRepository = new Mock <IAsyncRepository <IDbModel> >(); var mockUnitOfWork = new Mock <IDisposableUnitOfWork>(); var mockUnitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); mockUnitOfWorkFactory.Setup(factory => factory.CreateUnitOfWork()).Returns(mockUnitOfWork.Object); var genericAsyncService = new GenericAsyncService <IDbModel>(mockAsyncRepository.Object, mockUnitOfWorkFactory.Object); var validItemToAdd = new Mock <IDbModel>(); genericAsyncService.Add(validItemToAdd.Object); mockAsyncRepository.Verify(repo => repo.Add(validItemToAdd.Object), Times.Once); }
public void ShouldInvokeUnitOfWorkSaveChangesAsyncMethodOnce_WhenParametersAreCorrect() { var mockAsyncRepository = new Mock <IAsyncRepository <IDbModel> >(); var mockUnitOfWork = new Mock <IDisposableUnitOfWork>(); var mockUnitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); mockUnitOfWorkFactory.Setup(factory => factory.CreateUnitOfWork()).Returns(mockUnitOfWork.Object); var genericAsyncService = new GenericAsyncService <IDbModel>(mockAsyncRepository.Object, mockUnitOfWorkFactory.Object); var validItem = new Mock <IDbModel>(); genericAsyncService.Delete(validItem.Object); mockUnitOfWork.Verify(repo => repo.SaveChangesAsync(), Times.Once); }
public void ShouldReturnValueOfCorrectType() { var mockUnitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); var mockAsyncRepository = new Mock <IAsyncRepository <IDbModel> >(); mockAsyncRepository.Setup(repo => repo.GetAll(It.IsAny <Expression <Func <IDbModel, bool> > >())).Returns(() => { IEnumerable <IDbModel> result = new List <IDbModel>(); return(Task.Run(() => result)); }); var genericAsyncService = new GenericAsyncService <IDbModel>(mockAsyncRepository.Object, mockUnitOfWorkFactory.Object); var actualResult = genericAsyncService.GetDeleted(); Assert.That(actualResult, Is.InstanceOf <IEnumerable <IDbModel> >()); }
public void ShouldReturnTheResultOfTheRepositoryTask() { var mockAsyncRepository = new Mock <IAsyncRepository <IDbModel> >(); IEnumerable <IDbModel> repositoryQueryResult = new List <IDbModel>(); mockAsyncRepository.Setup(repo => repo.GetAllAsync()).Returns(() => Task.Run(() => repositoryQueryResult)); var mockUnitOfWork = new Mock <IDisposableUnitOfWork>(); var mockUnitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); mockUnitOfWorkFactory.Setup(factory => factory.CreateUnitOfWork()).Returns(mockUnitOfWork.Object); var genericAsyncService = new GenericAsyncService <IDbModel>(mockAsyncRepository.Object, mockUnitOfWorkFactory.Object); var actualResult = genericAsyncService.GetAll(); Assert.That(actualResult, Is.EqualTo(repositoryQueryResult)); }
public void ShouldReturnValueOfCorrectType() { var mockAsyncRepository = new Mock <IAsyncRepository <IDbModel> >(); mockAsyncRepository.Setup(repo => repo.GetAllAsync()).Returns(() => { IEnumerable <IDbModel> result = new List <IDbModel>(); return(Task.Run(() => result)); }); var mockUnitOfWork = new Mock <IDisposableUnitOfWork>(); var mockUnitOfWorkFactory = new Mock <IDisposableUnitOfWorkFactory>(); mockUnitOfWorkFactory.Setup(factory => factory.CreateUnitOfWork()).Returns(mockUnitOfWork.Object); var genericAsyncService = new GenericAsyncService <IDbModel>(mockAsyncRepository.Object, mockUnitOfWorkFactory.Object); var actualResult = genericAsyncService.GetAll(); Assert.That(actualResult, Is.InstanceOf <IEnumerable <IDbModel> >()); }