public void ShouldReturnTaskOfCorrectType_WhenItemIsFound()
{
var mockDbSet = new Mock <DbSet <IDbModel> >();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(mockDbSet.Object);
var asyncGenericRepositoryInstace = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
var fakeDeletedModel = new Mock <IDbModel>();
fakeDeletedModel.SetupGet(model => model.IsDeleted).Returns(true);
var fakeData = new List <IDbModel>()
{
fakeDeletedModel.Object
}
.AsQueryable();
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.Provider).Returns(fakeData.Provider);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.Expression).Returns(fakeData.Expression);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.ElementType).Returns(fakeData.ElementType);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.GetEnumerator()).Returns(fakeData.GetEnumerator());
var actualReturnedCollection = asyncGenericRepositoryInstace.GetDeleted();
Assert.That(actualReturnedCollection.GetType(), Is.EqualTo(typeof(Task <IEnumerable <IDbModel> >)));
}
public void ShouldReturnTaskWithResultCountZero_WhenItemIsNotFound()
{
var mockDbSet = new Mock <DbSet <IDbModel> >();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(mockDbSet.Object);
var asyncGenericRepositoryInstace = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
// Setup data
var fakeData = new List <IDbModel>()
{
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object
}
.AsQueryable();
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.Provider).Returns(fakeData.Provider);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.Expression).Returns(fakeData.Expression);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.ElementType).Returns(fakeData.ElementType);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.GetEnumerator()).Returns(fakeData.GetEnumerator());
Expression <Func <IDbModel, bool> > filter = (IDbModel model) => model.Id == 1;
var actualReturnedCollection = asyncGenericRepositoryInstace.GetAll(filter);
Assert.That(actualReturnedCollection.Result.Count, Is.EqualTo(0));
}
public void ChangeStateOf_Stateful_WhenCalledWithValidParameters()
{
// Arange
var mockedStaful = new Mock <IStateful <IDbModel> >();
mockedStaful.SetupSet(x => x.State = EntityState.Modified).Verifiable();
var fakeDbSet = new Mock <DbSet <IDbModel> >();
var fakeDbModel = new Mock <IDbModel>();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(fakeDbSet.Object);
mockDbContext.Setup(mock => mock.GetStateful(It.IsAny <IDbModel>())).Returns(mockedStaful.Object);
var asyncGenericRepositoryInstace = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
// Act
asyncGenericRepositoryInstace.Update(fakeDbModel.Object);
// Assert
mockedStaful.Verify();
}
public void ShouldThrowArgumentExceptionWithCorrectMessage_WhenPageSizeParameterIsNegative()
{
var mockDbSet = new Mock <DbSet <IDbModel> >();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(mockDbSet.Object);
var asyncGenericRepositoryInstace = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
// Setup data
var fakeData = new List <IDbModel>()
{
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object
}
.AsQueryable();
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.Provider).Returns(fakeData.Provider);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.Expression).Returns(fakeData.Expression);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.ElementType).Returns(fakeData.ElementType);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.GetEnumerator()).Returns(fakeData.GetEnumerator());
var page = 1;
var pageSize = -5;
Expression <Func <IDbModel, bool> > filter = (IDbModel model) => model.Id == 1;
Assert.That(
() => asyncGenericRepositoryInstace.GetAll(filter, page, pageSize),
Throws.InstanceOf <ArgumentException>().With.Message.Contains("Page Size must be a value equal to or greater than zero."));
}
public void ShouldThrowArgumentNullException_WhenFilterParameterIsNull()
{
var mockDbSet = new Mock <DbSet <IDbModel> >();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(mockDbSet.Object);
var asyncGenericRepositoryInstace = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
// Setup data
var fakeData = new List <IDbModel>()
{
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object
}
.AsQueryable();
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.Provider).Returns(fakeData.Provider);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.Expression).Returns(fakeData.Expression);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.ElementType).Returns(fakeData.ElementType);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.GetEnumerator()).Returns(fakeData.GetEnumerator());
Expression <Func <IDbModel, bool> > filter = null;
Assert.That(
() => asyncGenericRepositoryInstace.GetAll(filter),
Throws.InstanceOf <ArgumentNullException>().With.Message.Contains(nameof(filter)));
}
public void ShouldCreateAnObjectWhichImplementsIAsyncRepository()
{
var fakeDbSet = new Mock <DbSet <IDbModel> >();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(fakeDbSet.Object);
var asyncGenericRepository = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
Assert.That(asyncGenericRepository, Is.InstanceOf <IAsyncRepository <IDbModel> >());
}
public void ShouldNotThrow_WhenParametersAreCorrect()
{
var fakeDbSet = new Mock <DbSet <IDbModel> >();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(fakeDbSet.Object);
var asyncGenericRepository = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
Assert.That(asyncGenericRepository, Is.Not.Null);
}
public void ShouldInvoke_DbContextSetMethodOnce()
{
var fakeDbSet = new Mock <DbSet <IDbModel> >();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(fakeDbSet.Object);
var asyncGenericRepository = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
mockDbContext.Verify(mock => mock.Set <IDbModel>(), Times.Once);
}
public void ShouldSetCorrectValueToPrivateFieldDbSet_WhenParametersAreCorrect()
{
var fakeDbSet = new Mock <DbSet <IDbModel> >();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(fakeDbSet.Object);
var actualAsyncGenericRepositoryInstace = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
var fieldName = "dbSet";
var bindingFlags = BindingFlags.NonPublic | BindingFlags.Instance;
var dbSetField = actualAsyncGenericRepositoryInstace.GetType().GetField(fieldName, bindingFlags);
var dbSetFieldValue = dbSetField.GetValue(actualAsyncGenericRepositoryInstace);
Assert.That(dbSetFieldValue, Is.Not.Null.And.EqualTo(fakeDbSet.Object));
}
public async Task ShouldInvokeDbSetFindMethodWithCorrectIdParameter_WhenParametersAreValid()
{
var mockDbSet = new Mock <DbSet <IDbModel> >();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(mockDbSet.Object);
var asyncGenericRepositoryInstace = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
mockDbSet.Setup(mock => mock.Find(It.IsAny <int>())).Returns <IDbModel>(null);
var validId = 42;
await asyncGenericRepositoryInstace.GetByIdAsync(validId);
mockDbSet.Verify(mock => mock.Find(validId), Times.Once());
}
public void ShouldReturnTaskWithResultNull_WhenItemIsNotFound()
{
var mockDbSet = new Mock <DbSet <IDbModel> >();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(mockDbSet.Object);
var asyncGenericRepositoryInstace = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
mockDbSet.Setup(mock => mock.Find(It.IsAny <int>())).Returns <IDbModel>(null);
var validId = 42;
var actualReturnedModel = asyncGenericRepositoryInstace.GetByIdAsync(validId);
Assert.That(actualReturnedModel.Result, Is.Null);
}
public void ThrowArgumentExceptionWithCorrectMessage_WhenIdParameterValueIsNegative()
{
var mockDbSet = new Mock <DbSet <IDbModel> >();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(mockDbSet.Object);
var asyncGenericRepositoryInstace = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
mockDbSet.Setup(mock => mock.Find(It.IsAny <int>())).Returns <IDbModel>(null);
var invalidId = -42;
Assert.That(
() => asyncGenericRepositoryInstace.GetByIdAsync(invalidId),
Throws.InstanceOf <ArgumentException>().With.Message.Contains("Id must be a positive integer."));
}
public void ShouldReturnTaskWithCorrectResult_WhenItemIsFound()
{
var mockDbSet = new Mock <DbSet <IDbModel> >();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(mockDbSet.Object);
var asyncGenericRepositoryInstace = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
// Setup Data
var fakeMatchingModel = new Mock <IDbModel>();
fakeMatchingModel.SetupGet(model => model.Id).Returns(1);
var fakeData = new List <IDbModel>()
{
fakeMatchingModel.Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object
}
.AsQueryable();
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.Provider).Returns(fakeData.Provider);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.Expression).Returns(fakeData.Expression);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.ElementType).Returns(fakeData.ElementType);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.GetEnumerator()).Returns(fakeData.GetEnumerator());
var page = 0;
var pageSize = 5;
Expression <Func <IDbModel, bool> > filter = (IDbModel model) => model.Id == 1;
Expression <Func <IDbModel, int> > orderBy = (IDbModel model) => model.Id;
Expression <Func <IDbModel, Type> > select = (IDbModel model) => model.GetType();
var actualReturnedCollection = asyncGenericRepositoryInstace.GetAll(filter, orderBy, select, page, pageSize);
var expectedCollection = new List <Type>()
{
fakeMatchingModel.Object.GetType()
};
Assert.That(actualReturnedCollection.Result, Is.Not.Null.And.EquivalentTo(expectedCollection));
}
public void ShouldReturnTaskWithResultNull_WhenItemIsNotFound()
{
var mockDbSet = new Mock <DbSet <IDbModel> >();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(mockDbSet.Object);
var asyncGenericRepositoryInstace = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
var fakeData = new List <IDbModel>();
mockDbSet.As <IDbSet <IDbModel> >().Setup(mock => mock.GetEnumerator()).Returns(fakeData.GetEnumerator());
var actualReturnedCollection = asyncGenericRepositoryInstace.GetAllAsync();
Assert.That(actualReturnedCollection.Result.Count, Is.EqualTo(0));
}
public void ShouldReturnTaskOfCorrectType_WhenItemIsFound()
{
var mockDbSet = new Mock <DbSet <IDbModel> >();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(mockDbSet.Object);
var asyncGenericRepositoryInstace = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
var fakeDbModel = new Mock <IDbModel>();
mockDbSet.Setup(mock => mock.Find(It.IsAny <int>())).Returns(fakeDbModel.Object);
var validId = 42;
var actualReturnedModel = asyncGenericRepositoryInstace.GetByIdAsync(validId);
Assert.That(actualReturnedModel.GetType(), Is.EqualTo(typeof(Task <IDbModel>)));
}
public void ShouldReturnTaskOfCorrectStatus_WhenItemIsFound()
{
var mockDbSet = new Mock <DbSet <IDbModel> >();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(mockDbSet.Object);
var asyncGenericRepositoryInstace = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
var fakeDbModel = new Mock <IDbModel>();
mockDbSet.Setup(mock => mock.Find(It.IsAny <int>())).Returns(fakeDbModel.Object);
var validId = 42;
var actualReturnedModel = asyncGenericRepositoryInstace.GetByIdAsync(validId);
Assert.That(actualReturnedModel.Status, Is.EqualTo(TaskStatus.Running).Or.EqualTo(TaskStatus.WaitingToRun).Or.EqualTo(TaskStatus.RanToCompletion));
}
public void ThrowArgumentNullExceptionWithCorrectMessage_WhenEntityParameterIsNull()
{
// Arange
IDbModel entity = null;
var fakeDbSet = new Mock <DbSet <IDbModel> >();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(fakeDbSet.Object);
var asyncGenericRepositoryInstace = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
// Act & Assert
Assert.That(
() => asyncGenericRepositoryInstace.Update(entity),
Throws.InstanceOf <ArgumentNullException>().With.Message.Contains(nameof(entity)));
}
public void ShouldReturnTaskWithResultNull_WhenItemIsNotFound()
{
var mockDbSet = new Mock <DbSet <IDbModel> >();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(mockDbSet.Object);
var asyncGenericRepositoryInstace = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
// Setting up Linq methods
var fakeData = new List <IDbModel>().AsQueryable();
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.Provider).Returns(fakeData.Provider);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.Expression).Returns(fakeData.Expression);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.ElementType).Returns(fakeData.ElementType);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.GetEnumerator()).Returns(fakeData.GetEnumerator());
var actualReturnedCollection = asyncGenericRepositoryInstace.GetDeleted();
Assert.That(actualReturnedCollection.Result.Count, Is.EqualTo(0));
}
public void ShouldReturnTaskOfCorrectStatus_WhenItemIsFound()
{
var mockDbSet = new Mock <DbSet <IDbModel> >();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(mockDbSet.Object);
var asyncGenericRepositoryInstace = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
// Setup Data
var fakeMatchingModel = new Mock <IDbModel>();
fakeMatchingModel.SetupGet(model => model.Id).Returns(1);
var fakeData = new List <IDbModel>()
{
fakeMatchingModel.Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object
}
.AsQueryable();
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.Provider).Returns(fakeData.Provider);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.Expression).Returns(fakeData.Expression);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.ElementType).Returns(fakeData.ElementType);
mockDbSet.As <IQueryable <IDbModel> >().Setup(m => m.GetEnumerator()).Returns(fakeData.GetEnumerator());
var page = 0;
var pageSize = 5;
Expression <Func <IDbModel, bool> > filter = (IDbModel model) => model.Id == 1;
Expression <Func <IDbModel, int> > orderBy = (IDbModel model) => model.Id;
var actualReturnedCollection = asyncGenericRepositoryInstace.GetAll(filter, orderBy, page, pageSize);
Assert.That(actualReturnedCollection.Status, Is.EqualTo(TaskStatus.Running).Or.EqualTo(TaskStatus.WaitingToRun).Or.EqualTo(TaskStatus.RanToCompletion));
}
public void InvokeDbContextEntryMethodWithCorrectParameter_WhenParametersAreValid()
{
// Arange
var mockedStaful = new Mock <IStateful <IDbModel> >();
var fakeDbSet = new Mock <DbSet <IDbModel> >();
var fakeDbModel = new Mock <IDbModel>();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(fakeDbSet.Object);
mockDbContext.Setup(mock => mock.GetStateful(It.IsAny <IDbModel>())).Returns(mockedStaful.Object);
var asyncGenericRepositoryInstace = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
// Act
asyncGenericRepositoryInstace.Update(fakeDbModel.Object);
// Assert
mockDbContext.Verify(mock => mock.GetStateful(fakeDbModel.Object), Times.Once());
}
public void ShouldReturnTaskOfCorrectStatus_WhenItemIsFound()
{
var mockDbSet = new Mock <DbSet <IDbModel> >();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(mockDbSet.Object);
var asyncGenericRepositoryInstace = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
var fakeData = new List <IDbModel>()
{
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object
};
mockDbSet.As <IDbSet <IDbModel> >().Setup(mock => mock.GetEnumerator()).Returns(fakeData.GetEnumerator());
var actualReturnedCollection = asyncGenericRepositoryInstace.GetAllAsync();
Assert.That(actualReturnedCollection.Status, Is.EqualTo(TaskStatus.Running).Or.EqualTo(TaskStatus.WaitingToRun).Or.EqualTo(TaskStatus.RanToCompletion));
}
public void ShouldReturnTaskOfCorrectType_WhenItemIsFound()
{
var mockDbSet = new Mock <DbSet <IDbModel> >();
var mockDbContext = new Mock <IWhenItsDoneDbContext>();
mockDbContext.Setup(mock => mock.Set <IDbModel>()).Returns(mockDbSet.Object);
var asyncGenericRepositoryInstace = new GenericAsyncRepository <IDbModel>(mockDbContext.Object);
var fakeData = new List <IDbModel>()
{
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object,
new Mock <IDbModel>().Object
};
mockDbSet.As <IDbSet <IDbModel> >().Setup(mock => mock.GetEnumerator()).Returns(fakeData.GetEnumerator());
var actualReturnedCollection = asyncGenericRepositoryInstace.GetAllAsync();
Assert.That(actualReturnedCollection.GetType(), Is.EqualTo(typeof(Task <IEnumerable <IDbModel> >)));
}
public ClientAsyncService(PackageDbContext dbContext)
{
Repository = new GenericAsyncRepository <Client>(dbContext);
}
