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