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> >());
}
