protected virtual async Task AsQueryableTest(
Func <IIncludableQueryable <Product, ICollection <Part> >, Task <List <Product> > > toList)
{
// Create new empty database
using (var db = new SQLiteContext())
{
// Arrange
IEntityFrameworkRepository <Category> cr = new EntityFrameworkRepository <Category>(db);
var category = CreateCategory(100);
cr.Create(category);
IEntityFrameworkRepository <Product> pr = new EntityFrameworkRepository <Product>(db);
var q = pr
.AsQueryable()
.Where(p => p.Id > 1)
.Skip(2)
.Take(40)
.OrderBy(p => p.Name)
.Include(p => p.Parts);
// Act
var pageItems = await toList(q);
// Assert
Assert.NotNull(pageItems);
Assert.Equal(40, pageItems.Count());
}
}
protected virtual async Task FindSql_With_Parameters_And_Pattern_Test(
Func <IEntityFrameworkRepository <Product>, string, Dictionary <string, object>, string, Task <IEnumerable <Product> > > find)
{
// Create new empty database
using (var db = new SQLiteContext())
{
// Arrange
var cr = new EntityFrameworkRepository <Category>(db);
var category = CreateCategory(100);
cr.Create(category);
// Act
var pr = new EntityFrameworkRepository <Product>(db);
var result = await find(pr, "SELECT * FROM Product WHERE Id > :Id AND Description <> :Description",
new Dictionary <string, object>
{
{ "Description", "XXX" },
{ "Id", 50 }
},
@":(\w+)");
// Assert
Assert.NotNull(result);
Assert.Equal(50, result.Count());
}
}
protected virtual async Task Combine_Page_Sort_Include_AsQueryable_Test(
Func <IQueryable <Product>, Task <List <Product> > > toList)
{
// Create new empty database
using (var db = new SQLiteContext())
{
// Arrange
IEntityFrameworkRepository <Category> cr = new EntityFrameworkRepository <Category>(db);
var category = CreateCategory(100);
cr.Create(category);
IEntityFrameworkRepository <Product> pr = new EntityFrameworkRepository <Product>(db);
var q = pr
.Page(2, 40)
.Include("Parts")
.SortBy("Name")
.AsQueryable();
// Act
var pageItems = await toList(q);
// Assert
Assert.NotNull(pageItems);
Assert.Equal(40, pageItems.Count());
}
}
protected virtual async Task Combine_Page_Sort_Include_FindSql_Test(
Func <IEntityFrameworkRepository <Product>, string, Dictionary <string, object>, Task <IEnumerable <Product> > > find)
{
// Create new empty database
using (var db = new SQLiteContext())
{
// Arrange
IEntityFrameworkRepository <Category> cr = new EntityFrameworkRepository <Category>(db);
var category = CreateCategory(100);
cr.Create(category);
IEntityFrameworkRepository <Product> pr = new EntityFrameworkRepository <Product>(db)
.Page(2, 40)
.Include("Parts")
.SortBy("Name");
// Act
var pageItems = await find(pr, "SELECT * FROM Product WHERE Id > @Id AND Description <> @Description",
new Dictionary <string, object>
{
{ "Description", "XXX" },
{ "Id", 50 }
});
// Assert
Assert.NotNull(pageItems);
Assert.Equal(50, pr.TotalItems);
Assert.Equal(10, pageItems.Count());
}
}
public async Task should_add_new_course()
{
var testCourse = new Course
{
Id = 4,
Name = "C++",
TeacherId = 2,
CourseId = 1,
CourseNavigation = null,
Teacher = null,
PupilInCourse = null
};
_sut.Create(testCourse);
await _sut.UnitOfWork.SaveEntitiesAsync();
var addedCourse = _context.Course
.FirstOrDefault(_ => _.Id == testCourse.Id);
addedCourse.ShouldNotBeNull();
addedCourse.Id.ShouldBe(testCourse.Id);
addedCourse.Name.ShouldBe(testCourse.Name);
addedCourse.CourseId.ShouldBe(testCourse.CourseId);
addedCourse.TeacherId.ShouldBe(testCourse.TeacherId);
}
protected virtual async Task PageTest(
int page,
int pageSize,
int totalRows,
int expectedRows,
Func <IPageableRepository <Product>, Task <IEnumerable <Product> > > find)
{
// Create new empty database
using (var db = new SQLiteContext())
{
// Arrange
IPageableRepository <Category> cr = new EntityFrameworkRepository <Category>(db);
var category = CreateCategory(totalRows);
cr.Create(category);
IPageableRepository <Product> pr = new EntityFrameworkRepository <Product>(db)
.Page(page, pageSize);
// Act
var pageItems = await find(pr);
// Assert
Assert.NotNull(pageItems);
Assert.Equal(expectedRows, pageItems.Count());
Assert.Equal(totalRows, pr.TotalItems);
Assert.Equal(pageSize == 0 ? 1 : (totalRows / pageSize) + 1, pr.TotalPages);
Assert.Equal(page, pr.PageNumber);
Assert.Equal(page < 2 ? 1 : ((page - 1) * pageSize) + 1, pr.StartIndex);
}
}
public void EFCore_Should_Support_Circular_References()
{
// Create new empty database
using (var db = new SQLiteContext())
{
// Arrange
var cr = new EntityFrameworkRepository <Category>(db, null, false);
var c = CreateCategory(100);
cr.Create(c);
cr.SaveChanges();
// Detach all to avoid expansions already cached in the context
cr.DetachAll();
// Act
var cdb = cr
.Include("Products.Parts.Product")
.Find().First();
Assert.NotNull(cdb);
var products = cdb.Products;
// Assert
Assert.NotNull(products);
Assert.Equal(100, products.Count);
var product = products.First();
for (int i = 0; i < 10; i++)
{
Assert.NotNull(product);
Assert.NotNull(product.Parts);
var part = product.Parts.First();
product = part.Product;
}
}
}
// Create Personal Details
public static async Task <PersonalDetail> CreatePersonalDetails(PersonalDetailViewModel model)
{
try
{
using (var db = new WebApiProjectDbContext())
using (var repo = new EntityFrameworkRepository <WebApiProjectDbContext>(db))
{
var entity = new PersonalDetail()
{
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
BirthDate = model.BirthDate,
PhoneNumber = model.PhoneNumber,
Age = model.Age,
};
repo.Create <PersonalDetail>(entity);
var result = await db.SaveChangesAsync() == 0 ? null : entity;
return(result);
}
}
catch (Exception e)
{
Trace.WriteLine(e);
return(null);
}
}
public void AddReturnsAModelWithAnId()
{
var efRepo = new EntityFrameworkRepository(DbContext);
var book = ABook("The book");
var createdBook = (Book) efRepo.Create(book);
DbContext.SaveChanges();
Assert.AreEqual(book.Title, createdBook.Title);
Assert.AreNotEqual(0, createdBook.Id);
}
public void CreateWithNullShouldThrowArgument()
{
// Arrange
var context = new Mock <DbContext>();
var users = new List <User>();
context.Setup(m => m.Set <User>()).Returns(new FakeSet <User>(users));
var entityFrameworkRepository = new EntityFrameworkRepository <User, int>(context.Object);
// Act
entityFrameworkRepository.Create(null);
}
protected virtual async Task SortByTest(
bool descendingOrder,
bool useExpression,
Func <ISortableRepository <Product>, Task <IEnumerable <Product> > > find)
{
// Create new empty database
using (var db = new SQLiteContext())
{
// Arrange
ISortableRepository <Category> cr = new EntityFrameworkRepository <Category>(db);
var c = CreateCategory(100);
cr.Create(c);
ISortableRepository <Product> unsortedProductRepository = new EntityFrameworkRepository <Product>(db);
ISortableRepository <Product> sortedProductRepository = new EntityFrameworkRepository <Product>(db);
if (descendingOrder)
{
if (useExpression)
{
sortedProductRepository.SortByDescending("Name");
}
else
{
sortedProductRepository.SortByDescending(p => p.Name);
}
}
else
if (useExpression)
{
sortedProductRepository.SortBy("Name");
}
else
{
sortedProductRepository.SortBy(p => p.Name);
}
// Act
var sortedProducts = await find(sortedProductRepository);
var unsortedProducts = await find(unsortedProductRepository);
// Assert
var sortedList = descendingOrder
? sortedProducts.OrderByDescending(p => p.Name)
: sortedProducts.OrderBy(p => p.Name);
Assert.NotNull(sortedProducts);
Assert.Equal(sortedProducts, sortedList);
Assert.NotNull(unsortedProducts);
Assert.NotEqual(unsortedProducts, sortedList);
}
}
public void ThrowArgumentNullException_WhenTEntityParameterIsNull()
{
// Arrange
var parserDbContext = new Mock <IParserDbContext>();
var entities = new Mock <IDbSet <MockDbModel> >();
parserDbContext.Setup(c => c.Set <MockDbModel>()).Returns(entities.Object);
var entityFrameworkRepository = new EntityFrameworkRepository <MockDbModel>(parserDbContext.Object);
MockDbModel entity = null;
// Act & Assert
Assert.That(
() => entityFrameworkRepository.Create(entity),
Throws.InstanceOf <ArgumentNullException>().With.Message.Contains(nameof(entity)));
}
public void InvokeIQueryableTEntity_AddMethodOnceWithCorrectParameter()
{
// Arrange
var parserDbContext = new Mock <IParserDbContext>();
var entities = new Mock <IDbSet <MockDbModel> >();
parserDbContext.Setup(c => c.Set <MockDbModel>()).Returns(entities.Object);
var entityFrameworkRepository = new EntityFrameworkRepository <MockDbModel>(parserDbContext.Object);
var entity = new MockDbModel();
// Act
entityFrameworkRepository.Create(entity);
// Assert
entities.Verify(e => e.Add(entity), Times.Once);
}
protected async Task IncludeTest(
string includes,
int productRows,
int expectedProductRows,
int expectedPartRows,
Func <IEntityFrameworkRepository <Category>, int?, Task <Category> > getById)
{
// Create new empty database
using (var db = new SQLiteContext())
{
// Arrange
IEntityFrameworkRepository <Category> categoryRepository = new EntityFrameworkRepository <Category>(db)
.Include(includes);
var category = CreateCategory(productRows);
categoryRepository.Create(category);
// Detach all to avoid expansions already cached in the context
categoryRepository.DetachAll();
// Act
category = await getById(categoryRepository, category.Id);
// Assert
Assert.NotNull(category);
if (category.Products == null)
{
Assert.Equal(0, expectedProductRows);
}
else
{
Assert.Equal(expectedProductRows, category.Products.Count);
var product = category.Products.First();
if (product.Parts == null)
{
Assert.Equal(0, expectedPartRows);
}
else
{
Assert.Equal(expectedPartRows, product.Parts.Count);
}
}
}
}
public void CreateShouldAddEntity()
{
// Arrange
var context = new Mock <DbContext>();
var users = new List <User>();
context.Setup(m => m.Set <User>()).Returns(new FakeSet <User>(users));
var entityFrameworkRepository = new EntityFrameworkRepository <User, int>(context.Object);
var user = new User
{
Id = 3
};
// Act
entityFrameworkRepository.Create(user);
// Assert
Assert.AreEqual(1, users.Count);
Assert.AreEqual(3, users[0].Id);
}
protected virtual async Task FindSql_No_Parameters_Test(
Func <IEntityFrameworkRepository <Product>, string, Task <IEnumerable <Product> > > find)
{
// Create new empty database
using (var db = new SQLiteContext())
{
// Arrange
var cr = new EntityFrameworkRepository <Category>(db);
var category = CreateCategory(100);
cr.Create(category);
// Act
var pr = new EntityFrameworkRepository <Product>(db);
var result = await find(pr, "SELECT * FROM Product");
// Assert
Assert.NotNull(result);
Assert.Equal(100, result.Count());
}
}
public async Task should_add_new_class()
{
var testClass = new Class
{
Id = 4,
Name = "C4",
TeacherId = 1,
PupilInClass = null,
};
_sut.Create(testClass);
await _sut.UnitOfWork.SaveEntitiesAsync();
var addedClass = _context.Class
.FirstOrDefault(_ => _.Id == testClass.Id);
addedClass.ShouldNotBeNull();
addedClass.Id.ShouldBe(testClass.Id);
addedClass.Name.ShouldBe(testClass.Name);
addedClass.TeacherId.ShouldBe(testClass.TeacherId);
}
public void Join_Should_Work_Without_Expansion()
{
// Create new empty database
using (var db = new SQLiteContext())
{
// Arrange
var cr = new EntityFrameworkRepository <Category>(db);
var c = CreateCategory(100);
cr.Create(c);
// Act
var pr = new EntityFrameworkRepository <Part>(db);
var pdb = pr
.Find(p => p.Product.Id == 1).First();
Assert.NotNull(pdb);
// Assert
Assert.NotNull(pdb);
}
}
public void ReturnCorrectTEntityInstance()
{
// Arrange
var parserDbContext = new Mock <IParserDbContext>();
var entities = new Mock <IDbSet <MockDbModel> >();
parserDbContext.Setup(c => c.Set <MockDbModel>()).Returns(entities.Object);
var entityFrameworkRepository = new EntityFrameworkRepository <MockDbModel>(parserDbContext.Object);
var expectedReturnerIQueryableTEntityInstance = entities.Object;
var entity = new MockDbModel();
// Act
var actualReturnerTEntityInstance = entityFrameworkRepository.Create(entity);
// Assert
Assert.That(actualReturnerTEntityInstance, Is.SameAs(entity));
}
protected virtual async Task FindWhereTest(
Func <IEntityFrameworkRepository <Product>, Expression <Func <Product, bool> >, Task <IEnumerable <Product> > > find)
{
// Create new empty database
using (var db = new SQLiteContext())
{
// Arrange
IEntityFrameworkRepository <Category> cr = new EntityFrameworkRepository <Category>(db);
var category = CreateCategory(100);
cr.Create(category);
IEntityFrameworkRepository <Product> pr = new EntityFrameworkRepository <Product>(db)
.Include("Parts");
// Act
var pageItems = await find(pr, p => p.Id > 50);
// Assert
Assert.NotNull(pageItems);
Assert.Equal(50, pageItems.Count());
}
}
public async Task should_add_new_school()
{
var testSchool = new School
{
Id = 4,
Name = "MUNI",
Country = "CZE",
SchoolOwnsSeason = null,
Teacher = null
};
_sut.Create(testSchool);
await _sut.UnitOfWork.SaveEntitiesAsync();
var addedSchool = _context.School
.FirstOrDefault(_ => _.Id == testSchool.Id);
addedSchool.ShouldNotBeNull();
addedSchool.Id.ShouldBe(testSchool.Id);
addedSchool.Name.ShouldBe(testSchool.Name);
addedSchool.Country.ShouldMatch(testSchool.Country);
}
protected virtual async Task GetById_Alternative_Key_Test(
Func <IEntityFrameworkRepository <Order>, object, Task <Order> > getById)
{
// Create new empty database
using (var db = new SQLiteContext())
{
// Arrange
IEntityFrameworkRepository <Order> r =
new EntityFrameworkRepository <Order>(db, o => o.OrderKey);
var order = new Order {
OrderDate = DateTime.Now
};
r.Create(order);
// Act
var result = await getById(r, order.OrderKey);
// Assert
Assert.True(order.OrderKey > 0);
Assert.NotNull(result);
}
}
public async Task <bool> Add(T entity)
{
try
{
_errors.Clear();
_errorDetail.Clear();
using (var db = new WebApiProjectDbContext())
using (var repo = new EntityFrameworkRepository <WebApiProjectDbContext>(db))
{
repo.Create <T>(entity);
return(await db.SaveChangesAsync() == 0 ? false : true);
}
}
catch (Exception e)
{
Trace.WriteLine(e);
//Add Error message
_errors.Add("There was an error trying to send the information to the database ");
return(false);
}
}
public void EFCore_Should_Not_Support_Lazy_Load()
{
// Create new empty database
using (var db = new SQLiteContext())
{
// Arrange
var cr = new EntityFrameworkRepository <Category>(db, null, false);
var c = CreateCategory(100);
cr.Create(c);
cr.SaveChanges();
// Detach all to avoid expansions already cached in the context
cr.DetachAll();
// Act
var cdb = cr.Find().First();
Assert.NotNull(cdb);
// Assert
// Looks like lazy loading is not supported in EF Core
Assert.Null(cdb.Products);
}
}
protected virtual async Task FindSql_Wrong_Parameter_Test(
Func <IEntityFrameworkRepository <Product>, string, Dictionary <string, object>, Task <IEnumerable <Product> > > find)
{
// Create new empty database
using (var db = new SQLiteContext())
{
// Arrange
var cr = new EntityFrameworkRepository <Category>(db);
var category = CreateCategory(100);
cr.Create(category);
var pr = new EntityFrameworkRepository <Product>(db);
var sql = "SELECT * FROM Product WHERE Id > @Id";
var parameters = new Dictionary <string, object> {
{ "Wrong", 1 }
};
// Act
// Assert
await Assert.ThrowsAsync <ArgumentException>(async() => await find(pr, sql, null));
await Assert.ThrowsAsync <ArgumentException>(async() => await find(pr, sql, parameters));
}
}
public async Task should_add_new_teacher()
{
var testTeacher = new Teacher
{
Id = 5,
Firstname = "Geralt",
Lastname = "Of Rivia",
SchoolId = 3,
School = null,
Class = null,
Course = null
};
_sut.Create(testTeacher);
await _sut.UnitOfWork.SaveEntitiesAsync();
var addedTeacher = _context.Teacher
.FirstOrDefault(_ => _.Id == testTeacher.Id);
addedTeacher.ShouldNotBeNull();
addedTeacher.Firstname.ShouldBe(testTeacher.Firstname);
addedTeacher.Lastname.ShouldBe(testTeacher.Lastname);
addedTeacher.SchoolId.ShouldBe(testTeacher.SchoolId);
}
protected virtual async Task Combine_Page_Sort_Include_Find_Test(
Func <IPageableRepository <Product>, Task <IEnumerable <Product> > > find)
{
// Create new empty database
using (var db = new SQLiteContext())
{
// Arrange
IEntityFrameworkRepository <Category> cr = new EntityFrameworkRepository <Category>(db);
var category = CreateCategory(100);
cr.Create(category);
IEntityFrameworkRepository <Product> pr = new EntityFrameworkRepository <Product>(db)
.Page(2, 40)
.Include("Parts")
.SortBy("Name");
// Act
var pageItems = await find(pr);
// Assert
Assert.NotNull(pageItems);
Assert.Equal(40, pageItems.Count());
Assert.Equal(100, pr.TotalItems);
}
}
protected virtual async Task GetByIdTest(
Func <IEntityFrameworkRepository <Product>, object, Task <Product> > getById)
{
// Create new empty database
using (var db = new SQLiteContext())
{
// Arrange
IEntityFrameworkRepository <Category> cr = new EntityFrameworkRepository <Category>(db);
var category = CreateCategory(100);
cr.Create(category);
IEntityFrameworkRepository <Product> pr = new EntityFrameworkRepository <Product>(db)
.Include(p => p.Category)
.Include(p => p.Parts);
// Act
var product = await getById(pr, 1);
// Assert
Assert.NotNull(product);
Assert.Equal(1, product.Id);
Assert.NotNull(product.Category);
Assert.NotNull(product.Parts);
}
}
public void ShouldKnowToTalkToContextAndDbSetOnCreateRHINO()
{
var mocks = new Rhino.Mocks.MockRepository();
var dbContext = mocks.StrictMock<PukuDbContext>();
var dbSet = mocks.StrictMock<IDbSet<Book>>();
var newBook = new Book {Title = "Book"};
With.Mocks(mocks).Expecting(() =>
{
Expect.Call(dbContext.GetDbSet<Book>()).Return(dbSet);
Expect.Call(dbSet.Add(newBook));
})
.Verify(() =>
{
var efRepo = new EntityFrameworkRepository(dbContext);
efRepo.Create(newBook);
});
}
// POST api/values
public void Post([FromBody] Genre band)
{
_repository.Create(band, "elcapo");
_repository.Save();
}