public void AddRemoveCategory()
{
var context = new CoreDataContext();
var uow = new EntityFrameworkUnitOfWork(context);
var repo = new EntityFrameworkRepository<Guid, Category, GuidIdInitializer>(context);
var caregoryService = new DataService<Guid, Category, EntityFrameworkRepository<Guid, Category, GuidIdInitializer>>(uow, repo);
var newCategory = caregoryService.Add(new Category
{
Name = "Computres",
Categories = new List<Category>
{
new Category { Name = "-DeskTops" },
new Category { Name = "-Servers" },
new Category { Name = "-Laptops", Categories = new List<Category>
{
new Category { Name = "--Tablets" },
new Category { Name = "--Shmablets" },
}
},
}
});
var justAdded = caregoryService.Get(c => c.Id == newCategory.Id);
Assert.AreEqual(justAdded.Categories.Count, newCategory.Categories.Count);
caregoryService.Remove(justAdded);
justAdded = caregoryService.Get(c => c.Id == newCategory.Id);
Assert.IsNull(justAdded);
}
public static PerformerController GetPerformerController()
{
var context = new EntityFrameworkContextTest();
var repository = new EntityFrameworkRepository<Performer>(context);
var controller = new PerformerController(repository);
controller.Request = GetRequest();
return controller;
}
public static ClientController GetClientController()
{
var context = new EntityFrameworkContextTest();
var repository = new EntityFrameworkRepository<Client>(context);
var controller = new ClientController(repository);
controller.Request = GetRequest();
return controller;
}
public void ShouldKnowHowToObtainList()
{
AddTwoBooks(DbContext);
var efRepo = new EntityFrameworkRepository(DbContext);
var results = efRepo.List<Book>();
Assert.AreEqual(2, results.Count);
Assert.IsInstanceOfType(results.First(), typeof(Book));
}
public EntityFrameworkUnitOfWork(DbContext dbContext)
{
if (dbContext == null)
{
throw new ArgumentNullException("dbContext");
}
_dbContext = dbContext;
_repository = new EntityFrameworkRepository(dbContext);
}
public EntityFrameworkUnitOfWork(DbContext dbContext)
{
if (dbContext == null)
{
throw new ArgumentNullException(nameof(dbContext));
}
this.dbContext = dbContext;
this.repository = new EntityFrameworkRepository(dbContext);
}
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 Task InitializeAsync()
{
DbContextOptionsBuilder <TestDbContext> dbContextOptionsBuilder = new DbContextOptionsBuilder <TestDbContext>();
dbContextOptionsBuilder.UseInMemoryDatabase("Test");
_testDbContext = new TestDbContext(dbContextOptionsBuilder.Options);
_repository = new EntityFrameworkRepository <TestEntity>(_testDbContext);
return(Task.CompletedTask);
}
public void ReturnAnInstance_ParametersAreNotNull()
{
//Arrange
var mockedDbContext = new Mock <IShishaTimeDbContext>();
//Act
var efRepo = new EntityFrameworkRepository <MockedModel>(mockedDbContext.Object);
//Assert
Assert.IsInstanceOf <EntityFrameworkRepository <MockedModel> >(efRepo);
}
public void TestCourseAddWithoutRequiredFK()
{
var courses = new EntityFrameworkRepository <Course>(context);
var newCourse = new Course {
Name = "Testowe zajecia"
};
courses.Add(newCourse);
courses.SaveChanges();
}
public EntityFrameworkRepositoryTests()
{
var dbContextMockFactory = new DbContextMockFactory();
dbContextMock = dbContextMockFactory.CreateDbContextMock <YesMinisterDbContext>();
episodesDbSetMock = dbContextMock.SetupDbSet <YesMinisterDbContext, EpisodeEntity, int>(episodesSeriesOne, context => context.Episodes);
quotesDbSetMock = dbContextMock.SetupDbSet <YesMinisterDbContext, QuoteEntity, int>(quotes, context => context.Quotes);
episodeRepositorySUT = CreateEntityFrameworkRepository <EpisodeEntity>();
quoteRepositorySUT = CreateEntityFrameworkRepository <QuoteEntity>();
}
protected static IRepository GetRepository()
{
var dbContext = new IncDbContext("IncRealEFDb", typeof(DbEntity).Assembly);
dbContext.Configuration.ValidateOnSaveEnabled = false;
dbContext.Configuration.LazyLoadingEnabled = true;
var entityFrameworkRepository = new EntityFrameworkRepository(/*Pleasure.MockStrictAsObject<IEntityFrameworkSessionFactory>(mock => mock.Setup(r => r.GetCurrent()).Returns(dbContext))*/);
entityFrameworkRepository.SetProvider(new Lazy <DbContext>(() => dbContext));
return(entityFrameworkRepository);
}
public void TestConstructor_PassDbContextCorrectly_ShouldInitializeCorrectly()
{
// Arrange
var mockedDbContext = new Mock <ILogsDbContext>();
// Act
var repository = new EntityFrameworkRepository <FakeGenericRepositoryType>(mockedDbContext.Object);
// Assert
Assert.IsNotNull(repository);
}
public void ShouldKnowHowToEditAModelByItsIdWhenItExists()
{
var book = new Book {Id = 1, Title = "The Book"};
var dbContext = new Mock<PukuDbContext>();
dbContext.Setup(ctx => ctx.SetModified(book));
var efRepo = new EntityFrameworkRepository(dbContext.Object);
efRepo.Edit(book);
dbContext.Verify(ctx => ctx.SetModified(book));
}
public async Task <IEnumerable <object> > CreateManyAsync <T>(List <dynamic> items)
where T : class, new()
{
var repo = new EntityFrameworkRepository <T>(dbContext);
var newItems = JsonConvert.DeserializeObject <List <T> >(
JsonConvert.SerializeObject(items));
await repo.CreateManyAsync(newItems);
return(newItems);
}
public void Get_CanGetWritableEntity_WhenEntityExists()
{
using (var context = new FakeDbContext())
{
var repository = new EntityFrameworkRepository <FakeCustomer>(() => context);
var customer = repository.Get(1);
Assert.NotNull(customer);
Assert.Equal(EntityState.Unchanged, context.Entry(customer).State);
}
}
public void WhenGetIsCalledAndNoParametersAreSuppliedThenAllEntitiesAreReturned()
{
using (var context = new CountVonCountTestDbContext())
{
var sut = new EntityFrameworkRepository <CountVonCountTestDbContext>(context);
var entities = sut.Get <WordMetric>();
Assert.AreEqual(_expectedWordMetrics.Count, entities.Count());
}
}
public void Get_CanGetWritableEntity_WhenEntityExists()
{
using (var context = new FakeDbContext())
{
var repository = new EntityFrameworkRepository<FakeCustomer>(() => context);
var customer = repository.Get(1);
Assert.NotNull(customer);
Assert.Equal(EntityState.Unchanged, context.Entry(customer).State);
}
}
public void InvokesIParserDbContext_SetMethodWithOnceCorrectParameter()
{
// Arrange
var parserDbContext = new Mock <IParserDbContext>();
// Act
var actualInstance = new EntityFrameworkRepository <MockDbModel>(parserDbContext.Object);
// Assert
parserDbContext.Verify(c => c.Set <MockDbModel>(), Times.Once);
}
public void Query_CanGetReadOnlyEntity_WhichAreNotTrackedByContext()
{
using (var context = new FakeDbContext())
{
var repository = new EntityFrameworkRepository <FakeCustomer>(() => context);
var firstCustomer = repository.Query().First();
var isFirstCustomerTrackedByContext = context.Entry(firstCustomer).State != EntityState.Detached;
Assert.NotNull(firstCustomer);
Assert.Equal(false, isFirstCustomerTrackedByContext);
}
}
public void Query_CanGetReadOnlyEntity_WhichAreNotTrackedByContext()
{
using (var context = new FakeDbContext())
{
var repository = new EntityFrameworkRepository<FakeCustomer>(() => context);
var firstCustomer = repository.Query().First();
var isFirstCustomerTrackedByContext = context.Entry(firstCustomer).State != EntityState.Detached;
Assert.NotNull(firstCustomer);
Assert.Equal(false, isFirstCustomerTrackedByContext);
}
}
public async Task <IEnumerable <object> > ApplyQueryOptionsAsync <T>(ODataQueryOptions queryOptions)
where T : class
{
var repo = new EntityFrameworkRepository <T>(dbContext);
return(await Task.FromResult(repo
.Include(queryOptions.Expand)
.AsQueryable()
.OData()
.ApplyQueryOptionsWithoutSelectExpand(queryOptions)
.ToList()));
}
public void WhenGetIsCalledAndTakeIsSuppliedThenUpToThatNumberOfEntitiesAreReturned()
{
using (var context = new CountVonCountTestDbContext())
{
var sut = new EntityFrameworkRepository <CountVonCountTestDbContext>(context);
const int take = 3;
var entities = sut.Get <WordMetric>(null, null, take);
Assert.AreEqual(take, entities.Count());
}
}
static void Main(string[] args)
{
var repository = new EntityFrameworkRepository(new ShopContext(Settings.Default.TestConnection));
var items = repository.Find(new BuildingByAddress("One Hanover Way"));
foreach (var product in items)
{
Console.WriteLine(product.Description);
}
Console.ReadLine();
}
public void CreatesCorrectIEntityFrameworkRepositoryInstance_WhenParametersAreValid()
{
// Arrange
var parserDbContext = new Mock <IParserDbContext>();
// Act
var actualInstance = new EntityFrameworkRepository <MockDbModel>(parserDbContext.Object);
// Assert
Assert.That(actualInstance, Is.Not.Null);
Assert.That(actualInstance, Is.InstanceOf <IEntityFrameworkRepository <MockDbModel> >());
}
public void UpdateShouldChangeEntityState()
{
// 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.Update(null);
}
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);
}
public void Delete_CanMarkEntityForDeletion_WhenEntityExists()
{
using (var context = new FakeDbContext())
{
var repository = new EntityFrameworkRepository<FakeCustomer>(() => context);
var customer = repository.Get(1);
Assert.NotNull(customer);
repository.Delete(customer);
Assert.Equal(EntityState.Deleted, context.Entry(customer).State);
}
}
public void Delete_CanMarkEntityForDeletion_WhenEntityExists()
{
using (var context = new FakeDbContext())
{
var repository = new EntityFrameworkRepository <FakeCustomer>(() => context);
var customer = repository.Get(1);
Assert.NotNull(customer);
repository.Delete(customer);
Assert.Equal(EntityState.Deleted, context.Entry(customer).State);
}
}
private static EmployeeProjectsFacade GetFacade(DbContextOptions <EmployeeProjectDbContext> options)
{
var dateTimeProvider = new LocalDateTimeProvider();
IUnitOfWorkProvider unitOfWorkProvider = new EntityFrameworkUnitOfWorkProvider(new AsyncLocalUnitOfWorkRegistry(), () => new EmployeeProjectDbContext(options));
Func <IFilteredQuery <EmployeeProjectDTO, EmployeeProjectFilterDTO> > queryFactory = () => new Mock <IFilteredQuery <EmployeeProjectDTO, EmployeeProjectFilterDTO> >().Object;
var mapper = CreateMapper();
var entityMapper = new EntityDTOMapper <EmployeeProject, EmployeeProjectDTO>(mapper);
var respository = new EntityFrameworkRepository <EmployeeProject, int>(unitOfWorkProvider, dateTimeProvider);
var parentRepository = new EntityFrameworkRepository <Employee, int>(unitOfWorkProvider, dateTimeProvider);
var facade = new EmployeeProjectsFacade(queryFactory, entityMapper, respository, parentRepository, dateTimeProvider, unitOfWorkProvider);
return(facade);
}
public void CallContextSetMethod()
{
//Arrange
var mockedContext = new Mock <IShishaTimeDbContext>();
mockedContext.Setup(x => x.Set <MockedModel>()).Verifiable();
//Act
var repository = new EntityFrameworkRepository <MockedModel>(mockedContext.Object);
//Assert
mockedContext.Verify(x => x.Set <MockedModel>(), Times.Once);
}
private CatalogModel FilterCatalog(ProductFilter filter)
{
// Should resolve IRepository from IoC Container
IRepository repository = new EntityFrameworkRepository(new CatalogDataContext("name=CatalogDataContext"));
// Create specification
var specification = new ProductFilterSpecification(filter.PriceFrom, filter.PriceTo);
// Get products
var products = repository.Query(specification);
return new CatalogModel { Filter = filter, Products = products };
}
public void TestInstructorGetByOwner()
{
var instructors = new EntityFrameworkRepository <Instructor>(context);
var owner = users.GetAll().Where(t => t.Username == "UzytkownikTrzy").First();
Assert.IsNotNull(owner);
var ins = instructors.GetByOwner(owner);
var names = ins.Select(t => t.Name);
var expected = new[] { "Prowadzacy Szesc", "Prowadzacy Siedem", "Prowadzacy Osiem" };
CollectionAssert.AreEqual(expected.ToList(), names.ToList());
}
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 WhenGetIsCalledAndOrderByIsSuppliedAllEntitiesAreReturnedInOrder()
{
using (var context = new CountVonCountTestDbContext())
{
var sut = new EntityFrameworkRepository <CountVonCountTestDbContext>(context);
IOrderedQueryable <WordMetric> OrderByDesc(IQueryable <WordMetric> words) => words.OrderByDescending(x => x.Count);
var expectedOrder = OrderByDesc(_expectedWordMetrics.AsQueryable()).ToList();
var entities = sut.Get <WordMetric>(null, OrderByDesc);
CollectionAssert.AreEqual(expectedOrder, entities, new WordMetricComparer());
}
}
public void ShouldKnowHowToGetModelFromTheirId()
{
var book = new Book {Id = 1, Title = "The Book"};
var dbContext = new Mock<PukuDbContext>();
var dbSet = new Mock<IDbSet<Book>>();
dbSet.Setup(set => set.Find(1)).Returns(book);
dbContext.Setup(context => context.GetDbSet<Book>()).Returns(dbSet.Object);
var efRepo = new EntityFrameworkRepository(dbContext.Object);
var foundBook = efRepo.Get<Book>(1);
Assert.AreEqual(book, foundBook);
dbContext.Verify(context => context.GetDbSet<Book>(), Times.Once());
dbSet.Verify(set => set.Find(1), Times.Once());
}
public void ReturnNull_WhenRequestedGuidDoesNotExist()
{
// 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 fakeData = new HashSet <MockDbModel>()
{
new MockDbModel()
{
Id = Guid.NewGuid()
},
new MockDbModel()
{
Id = Guid.NewGuid()
},
new MockDbModel()
{
Id = Guid.NewGuid()
},
new MockDbModel()
{
Id = Guid.NewGuid()
},
new MockDbModel()
{
Id = Guid.NewGuid()
}
};
var fakeDataQueryable = fakeData.AsQueryable();
entities.As <IQueryable>().Setup(e => e.GetEnumerator()).Returns(fakeDataQueryable.GetEnumerator());
entities.As <IQueryable>().Setup(e => e.ElementType).Returns(fakeDataQueryable.ElementType);
entities.As <IQueryable>().Setup(e => e.Expression).Returns(fakeDataQueryable.Expression);
entities.As <IQueryable>().Setup(e => e.Provider).Returns(fakeDataQueryable.Provider);
var entityGuid = Guid.NewGuid();
// Act
var actualReturnedTEntity = entityFrameworkRepository.Find(entityGuid);
// Assert
Assert.That(actualReturnedTEntity, Is.Null);
}
public void TestUpdate_ShouldCallDbContextSetUpdated()
{
// Arrange
var mockedDbContext = new Mock <ILogsDbContext>();
var repository = new EntityFrameworkRepository <FakeGenericRepositoryType>(mockedDbContext.Object);
var entity = new Mock <FakeGenericRepositoryType>();
// Act
repository.Update(entity.Object);
// Assert
mockedDbContext.Verify(c => c.SetUpdated(entity.Object), Times.Once);
}
public static void RegisterTypes(IUnityContainer container)
{
container.RegisterInstance(typeof(IUnityContainer), container);
var courseUnitRepo = new EntityFrameworkRepository<CourseUnit>(new CourseObjectContext("dolphin_db"));
var courseLessonRepo = new EntityFrameworkRepository<CourseLesson>(new CourseObjectContext("dolphin_db"));
var textResourceRepo = new EntityFrameworkRepository<TextResource>(new ResourceObjectContext("dolphin_db"));
var imageResourceRepo = new EntityFrameworkRepository<ImageResource>(new ResourceObjectContext("dolphin_db"));
container.RegisterInstance(typeof(IRepository<CourseUnit>), courseUnitRepo);
container.RegisterInstance(typeof(IRepository<CourseLesson>), courseLessonRepo);
container.RegisterInstance(typeof(IRepository<TextResource>), textResourceRepo);
container.RegisterInstance(typeof(IRepository<ImageResource>), imageResourceRepo);
container.RegisterType<ISearchService, SearchService>();
container.RegisterType<ICacheManager, MemoryCacheManager>();
container.RegisterType<ICourseContentService, CourseContentService>();
}
public void ReturnDbSet()
{
//Arrange
var mockedContext = new Mock <IShishaTimeDbContext>();
var mockedSet = new Mock <IDbSet <MockedModel> >();
mockedContext.Setup(x => x.Set <MockedModel>()).Returns(mockedSet.Object);
var repository = new EntityFrameworkRepository <MockedModel>(mockedContext.Object);
//Act
var result = repository.All;
//Assert
Assert.AreEqual(mockedSet.Object, result);
}
public void Save_CanCreateEntity_WhenEntityIsNotTrackedByContext()
{
using (var context = new FakeDbContext())
{
var repository = new EntityFrameworkRepository<FakeCustomer>(() => context);
var customer = new FakeCustomer
{
FirstName = "John",
LastName = "Doe"
};
repository.Save(customer);
Assert.Equal(EntityState.Added, context.Entry(customer).State);
}
}
private CatalogModel FilterCatalog(ProductFilter filter)
{
// Should resolve IRepository from IoC Container
IRepository repository = new EntityFrameworkRepository(new CatalogDataContext("name=CatalogDataContext"));
// Create specification
var specification = new ProductFilterSpecification(filter.PriceFrom, filter.PriceTo);
// Get products
var products = repository.Query(specification);
return(new CatalogModel {
Filter = filter, Products = products
});
}
public void Save_CanCreateEntity_WhenEntityIsNotTrackedByContext()
{
using (var context = new FakeDbContext())
{
var repository = new EntityFrameworkRepository <FakeCustomer>(() => context);
var customer = new FakeCustomer
{
FirstName = "John",
LastName = "Doe"
};
repository.Save(customer);
Assert.Equal(EntityState.Added, context.Entry(customer).State);
}
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RegisterGlobalFilters(GlobalFilters.Filters);
RegisterRoutes(RouteTable.Routes);
Mapper.CreateMap <TestItem, TestItemVM>();
Mapper.CreateMap <Test, TestVM>();
//Database.SetInitializer(new EntityFrameworkRepositoryInitializer());
using (var ctx = new EntityFrameworkRepository())
{
var foo = ctx.Tests.Count();
}
}
public void Init()
{
Database.SetInitializer <ModelContext>(new EntityFrameworkDbInitializer());
context = new ModelContext("Server=localhost;User Id=liszcz;Password=usFnsiUD;Database=liszcz;");
context.Database.Initialize(true);
var usersRepo = new EntityFrameworkRepository <User>(context);
users = new EntityController <User>(usersRepo);
users.Request = new System.Net.Http.HttpRequestMessage();
var coursesRepo = new EntityFrameworkRepository <Course>(context);
courses = new EntityController <Course>(coursesRepo);
courses.Request = new System.Net.Http.HttpRequestMessage();
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RegisterGlobalFilters(GlobalFilters.Filters);
RegisterRoutes(RouteTable.Routes);
Mapper.CreateMap<TestItem, TestItemVM>();
Mapper.CreateMap<Test, TestVM>();
//Database.SetInitializer(new EntityFrameworkRepositoryInitializer());
using (var ctx= new EntityFrameworkRepository())
{
var foo = ctx.Tests.Count();
}
}
public void ShouldKnowHowToDeleteAModelByItsIdWhenItExists()
{
var book = new Book {Id = 1, Title = "The Book"};
var dbContext = new Mock<PukuDbContext>();
var dbSet = new Mock<IDbSet<Book>>();
dbSet.Setup(set => set.Find(book.Id)).Returns(book);
dbSet.Setup(set => set.Remove(book));
dbContext.Setup(context => context.GetDbSet<Book>()).Returns(dbSet.Object);
var efRepo = new EntityFrameworkRepository(dbContext.Object);
efRepo.Delete<Book>(book.Id);
dbContext.Verify(context => context.GetDbSet<Book>(), Times.Once());
dbSet.Verify(set => set.Find(book.Id), Times.Once());
dbSet.Verify(set => set.Remove(book), Times.Once());
}
public void Run()
{
var efRepository = new EntityFrameworkRepository<Person>(new DbContext(String.Empty));
var allPeople = efRepository.GetAll();
var personRepository = new PersonRepository(new DbContext(String.Empty));
var children = personRepository.GetChildren();
var memoryRepository = new InMemoryRepository<Person>();
memoryRepository.Add(new Person
{
Id = 42,
Age = 10,
Name = "Artanis"
});
}
public void WhenGetIsCalledAndWhereIsSuppliedEntitiesSatisfyingTheClauseAreReturned()
{
using (var context = new CountVonCountTestDbContext())
{
var sut = new EntityFrameworkRepository <CountVonCountTestDbContext>(context);
var secondTopCount = _expectedWordMetrics.OrderByDescending(w => w.Count).ToArray()[1].Count;
var expectedEntities = _expectedWordMetrics.Where(w => w.Count > secondTopCount);
Expression <Func <WordMetric, bool> > where = wordM => wordM.Count > secondTopCount;
var entities = sut.Get(where);
CollectionAssert.AreEqual(expectedEntities.OrderBy(x => x.Count), entities.OrderBy(x => x.Count),
new WordMetricComparer());
}
}
public void Save_CanUpdateEntity_WhenEntityIsTrackedByContext()
{
using (var context = new FakeDbContext())
{
var repository = new EntityFrameworkRepository<FakeCustomer>(() => context);
var customer = repository.Get(1);
Assert.Equal("John", customer.FirstName);
// Change name
customer.FirstName = "Artina";
repository.Save(customer);
var affectedRows = context.SaveChanges();
Assert.Equal(1, affectedRows);
customer = repository.Get(1);
Assert.Equal("Artina", customer.FirstName);
}
}
private void SetConcreteRepositories()
{
_DepartmentRepo = new EntityFrameworkRepository<DepartmentEntity>(this);
_EmployeeLeaveRepo = new EntityFrameworkRepository<EmployeeLeaveEntity>(this);
_EmployeeRepo = new EntityFrameworkRepository<EmployeeEntity>(this);
_EmployeeTypeRepo = new EntityFrameworkRepository<EmployeeTypeEntity>(this);
_LeaveTypeRepo = new EntityFrameworkRepository<LeaveTypeEntity>(this);
_LogRepo = new EntityFrameworkRepository<LogEntity>(this);
}
public TaaltestController()
{
testRepository = new EntityFrameworkRepository();
}
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);
});
}
protected override IRepository GetRepository(
IEnumerable<BlogMeta> blogMetas = null,
IEnumerable<BlogPost> blogPosts = null)
{
var dbContext = BlavenDbContextTestFactory.CreateWithData(blogMetas, blogPosts);
var repository = new EntityFrameworkRepository(dbContext);
return repository;
}
public HomeController(EntityFrameworkRepository repository)
{
_repository = repository;
}
public void ShouldKnowToTalkToContextToSaveChanges()
{
var dbContext = new Mock<PukuDbContext>();
dbContext.Setup(context => context.SaveChanges());
var efRepo = new EntityFrameworkRepository(dbContext.Object);
efRepo.SaveChanges();
dbContext.Verify(context => context.SaveChanges(), Times.Once());
}
