public async Task CategoryExpenseAdd_TryingAddNewObjectToDB_ShouldBeAbleReturnIdEquals8()
{
// Arrange
mockMapper.Setup(x => x.Map <List <Entities.CategoryExpense> >(It.IsAny <List <Models.CategoryExpense> >()))
.Returns(It.IsAny <List <Entities.CategoryExpense> >());
mockRepo.Setup(y => y.AddRangeAsync(It.IsAny <IEnumerable <Entities.CategoryExpense> >()))
.Returns(() => Task.Run(() => { return(true); })).Verifiable();
mockRepo.Setup(y => y.SaveAsync())
.Returns(() => Task.Run(() => { return(true); })).Verifiable();
categoryExpenseEntityLists = new List <Entities.CategoryExpense>
{
new Entities.CategoryExpense {
Id = 8, Description = "New category Expense was added"
}
};
var sut = new CategoryExpenseService(mockRepo.Object, mockMapper.Object);
// Act
var resultOfAddCategoryExpense = await sut.AddCategoryExpense(categoryExpenseModelLists);
await context.CategoryExpenses.AddRangeAsync(categoryExpenseEntityLists);
await context.SaveChangesAsync();
var isAddedNewObject = queryDBInMemory.GetAsync(8);
// Assert
Assert.AreEqual(8, isAddedNewObject.Result.Id, "New object was not added, require id=8");
Assert.IsTrue(resultOfAddCategoryExpense, "Add and Save should return true. Object i added to Database");
mockRepo.Verify(
x => x.AddRangeAsync(It.IsAny <IEnumerable <Entities.CategoryExpense> >()),
Times.Once, "AddRangeAsync should run once");
mockRepo.Verify(
x => x.SaveAsync(), Times.Once, "SaveAsync should run once");
}
public async Task CategoryExpensePut_TryingChangeEditingObjectInDB_ShouldBeAbleEditObjectAndSaveChangesToDatabase()
{
// Arrange
mockRepo.Setup(y => y.GetAsync(It.IsAny <int>()))
.Returns(Task.FromResult(categoryExpenseEntityObj));
mockRepo.Setup(y => y.SaveAsync())
.Returns(() => Task.Run(() => { return(true); })).Verifiable();
var sut = new CategoryExpenseService(mockRepo.Object, null);
categoryExpenseModelObj = new Models.CategoryExpense {
Id = 2, Description = "x2 Changed"
};
var entityFromDB = queryDBInMemory.GetAsync(2);
entityFromDB.Result.Description = categoryExpenseModelObj.Description;
await context.SaveChangesAsync();
var isUpdatedNewObject = queryDBInMemory.GetAsync(2);
// Act
var resultOfEditCategoryExpense = await sut.EditCategoryExpense(categoryExpenseModelObj, 2);
// Assert
Assert.IsTrue(resultOfEditCategoryExpense, "SaveAsync should successful when edit CategoryExpense.");
Assert.AreEqual(2, isUpdatedNewObject.Result.Id, "Object was not updated, require id=2");
Assert.AreEqual("x2 Changed", isUpdatedNewObject.Result.Description, "Object was not updated, require Description=x2 Changed");
mockRepo.Verify(
x => x.GetAsync(It.IsAny <int>()), Times.Once, "GetAsync should run once");
mockRepo.Verify(
x => x.SaveAsync(), Times.Once, "SaveAsync should run once");
}
public async Task RemoveCategoryExpense_ShouldBeAbleToRemoveOneObjectWithIdEquals1()
{
// Arrange
categoryExpenseEntityObj = new Entities.CategoryExpense {
Id = 1, Description = "description1"
};
mockRepo.Setup(y => y.GetAsync(It.IsAny <int>()))
.Returns(Task.FromResult(categoryExpenseEntityObj));
mockRepo.Setup(y => y.RemoveAsync(It.IsAny <Entities.CategoryExpense>()))
.Returns(Task.FromResult(true));
var sut = new CategoryExpenseService(mockRepo.Object, null);
var getEntity = await sut.GetAsync(1);
// Act
var isRemoved = await sut.RemoveAsync(getEntity);
// Assert
Assert.AreEqual(1, getEntity.Id, "GetAsync doesn't return correct Object");
Assert.IsTrue(isRemoved, "RemoveAsync doesn't removed correct Object");
mockRepo.Verify(x => x.GetAsync(1), Times.Once, "GetAsync should run once");
mockRepo.Verify(x => x.RemoveAsync(getEntity),
Times.Once, "RemoveAsync should run once");
}
public async Task GetAllCategoryExpense_ShouldBeAbleToReturnTwoObjects()
{
// Arrange
categoryExpenseEntityLists = new List <Entities.CategoryExpense>()
{
new Entities.CategoryExpense {
Id = 8, Description = "description8"
},
new Entities.CategoryExpense {
Id = 9, Description = "description9"
}
}.AsEnumerable();
mockRepo.Setup(y => y.GetAllAsync())
.Returns(Task.FromResult(categoryExpenseEntityLists));
var sut = new CategoryExpenseService(mockRepo.Object, null);
// Act
var getAllEntities = await sut.GetAllAsync();
// Assert
Assert.AreEqual(2, getAllEntities.Count(), "GetAll doesn't return correct Count");
mockRepo.Verify(x => x.GetAllAsync(), Times.Once, "GetAllAsync should run once");
}
public async Task PutCategoryExpense_ShouldBeAbleToReturnFalseWhenGetAsyncReturnNull()
{
// Arrange
mockRepo.Setup(y => y.GetAsync(It.IsAny <int>()))
.Returns(Task.FromResult((Entities.CategoryExpense)null));
var sut = new CategoryExpenseService(mockRepo.Object, null);
// Act
var resultOfEditCategoryExpense = await sut.EditCategoryExpense(categoryExpenseModelObj, 1);
// Assert
Assert.IsFalse(resultOfEditCategoryExpense, "GetAsync should return null.");
mockRepo.Verify(x => x.GetAsync(It.IsAny <int>()), Times.Once, "GetAsync should run once");
}
public async Task AddCategoryExpense_ShouldRunAddRangeAsyncOnlyOnce()
{
// Arrange
mockMapper.Setup(x => x.Map <List <Entities.CategoryExpense> >(It.IsAny <List <Models.CategoryExpense> >()))
.Returns(It.IsAny <List <Entities.CategoryExpense> >());
mockRepo.Setup(y => y.AddRangeAsync(It.IsAny <IEnumerable <Entities.CategoryExpense> >()))
.Returns(() => Task.Run(() => { })).Verifiable();
var sut = new CategoryExpenseService(mockRepo.Object, mockMapper.Object);
// Act
await sut.AddCategoryExpense(categoryExpenseModelLists);
// Assert
mockRepo.Verify(
x => x.AddRangeAsync(It.IsAny <IEnumerable <Entities.CategoryExpense> >()),
Times.Once, "AddRangeAsync should run once");
}
public async Task GetCategoryExpense_ShouldBeAbleToReturnOneObjectWithIdEquals8()
{
// Arrange
categoryExpenseEntityObj = new Entities.CategoryExpense {
Id = 8, Description = "description8"
};
mockRepo.Setup(y => y.GetAsync(It.IsAny <int>()))
.Returns(Task.FromResult(categoryExpenseEntityObj));
var sut = new CategoryExpenseService(mockRepo.Object, null);
// Act
var getAllEntities = await sut.GetAsync(8);
// Assert
Assert.AreEqual(8, getAllEntities.Id, "GetAsync doesn't return correct Object");
mockRepo.Verify(x => x.GetAsync(8), Times.Once, "GetAsync should run once");
}
public async Task PutCategoryExpense_ShouldBeAbleToReturnTrueWhenSaveAsyncSuccessful()
{
// Arrange
mockRepo.Setup(y => y.GetAsync(It.IsAny <int>()))
.Returns(Task.FromResult(categoryExpenseEntityObj));
mockRepo.Setup(y => y.SaveAsync())
.Returns(() => Task.Run(() => { return(true); })).Verifiable();
var sut = new CategoryExpenseService(mockRepo.Object, null);
// Act
var resultOfEditCategoryExpense = await sut.EditCategoryExpense(categoryExpenseModelObj, 1);
// Assert
Assert.IsTrue(resultOfEditCategoryExpense, "SaveAsync should successful when edit CategoryExpense.");
mockRepo.Verify(
x => x.GetAsync(1), Times.Once, "GetAsync should run once");
mockRepo.Verify(
x => x.SaveAsync(), Times.Once, "SaveAsync should run once");
}
public async Task AddCategoryExpense_ShouldNotBeAbleToAddCategoryExpense()
{
// Arrange
mockMapper.Setup(x => x.Map <List <Entities.CategoryExpense> >(It.IsAny <List <Models.CategoryExpense> >()))
.Returns(It.IsAny <List <Entities.CategoryExpense> >());
mockRepo.Setup(y => y.AddRangeAsync(It.IsAny <IEnumerable <Entities.CategoryExpense> >()))
.Returns(() => Task.Run(() => { return(true); })).Verifiable();
mockRepo.Setup(y => y.SaveAsync())
.Returns(() => Task.Run(() => { return(false); })).Verifiable();
var sut = new CategoryExpenseService(mockRepo.Object, mockMapper.Object);
// Act
var resultOfAddCategoryExpense = await sut.AddCategoryExpense(categoryExpenseModelLists);
// Assert
Assert.IsFalse(resultOfAddCategoryExpense, "Save should return false");
mockRepo.Verify(
x => x.AddRangeAsync(It.IsAny <IEnumerable <Entities.CategoryExpense> >()), Times.Once, "AddRangeAsync should run once");
mockRepo.Verify(
x => x.SaveAsync(), Times.Once, "SaveAsync should run once");
}
