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 void TestMethod1() { var dbContext = new DanwuDbContext(); var context = new EntityFrameworkRepositoryContext(); var unitOfWork = new EntityFrameworkUnitOfWork(dbContext); IUserRepository userRepository = new UserRepository(context); userRepository.Create(new User() { UserName = "******", NickName = "坏坏男孩", RealName = "吴丹", PhoneNum = "18916765826", Email = "*****@*****.**", Status = UserStatus.Enabled, PassWord = "******", RegisterTime = DateTime.Now, LastLogonTime = DateTime.Now }); userRepository.Create(new User() { UserName = "******", NickName = "坏坏男孩1", RealName = "吴丹1", PhoneNum = "18916765000", Email = "*****@*****.**", Status = UserStatus.Disabled, PassWord = "******", RegisterTime = DateTime.Now, LastLogonTime = DateTime.Now }); var result = context.Commit(); //var result = unitOfWork.Commit(); }
public void TestChangePassword() { var context = new TestDotvvmRequestContext() { Configuration = this.Configuration, ApplicationHostPath = "../Netfox.Web.App/", Parameters = new Dictionary <string, object>() }; this.UserFacade.Save(new UserDTO() { Firstname = "test", IsEnable = true, Username = "******", Surname = "test", RoleId = this.AdminRoleID }, "testpass"); var viewModel = this.Container.Resolve <ProfileViewModel>(new { Context = context, Username = "******" }); viewModel.User = UserFacade.GetUser("testuser"); viewModel.Password = "******"; viewModel.NewPassword = "******"; viewModel.ChangePassword(); using (var uow = this.UnitOfWorkProvider.Create()) { var ctx = EntityFrameworkUnitOfWork.TryGetDbContext <NetfoxWebDbContext>(this.UnitOfWorkProvider); var passHash = this.UserFacade.LoginFacade.SHA256Hash("newtestpass"); Assert.AreEqual(ctx.Users.Count(u => u.Surname == "test" && u.Firstname == "test" && u.Username == "testuser" && u.Password == passHash), 1); } }
public void TestRemoveUser() { this.UserFacade.Save(new UserDTO() { Firstname = "test", IsEnable = true, Username = "******", Surname = "test", RoleId = this.AdminRoleID }, "testpass"); using (var uow = this.UnitOfWorkProvider.Create()) { var ctx = EntityFrameworkUnitOfWork.TryGetDbContext <NetfoxWebDbContext>(this.UnitOfWorkProvider); Assert.AreEqual(ctx.Users.Count(), 1); } var context = new TestDotvvmRequestContext() { Configuration = this.Configuration, ApplicationHostPath = "../Netfox.Web.App/", }; var viewModel = this.Container.Resolve <UserManagementViewModel>(new { Context = context, }); viewModel.Init(); viewModel.PreRender(); viewModel.RemoveUser(viewModel.Helper.Items.Items.First().Id); using (var uow = this.UnitOfWorkProvider.Create()) { var ctx = EntityFrameworkUnitOfWork.TryGetDbContext <NetfoxWebDbContext>(this.UnitOfWorkProvider); Assert.AreEqual(ctx.Users.Count(), 0); } }
public void TestRemoveInvestigation() { this.AddUser(); this.AddInvestigation(); var context = new TestDotvvmRequestContext() { Configuration = this.Configuration, ApplicationHostPath = "../Netfox.Web.App/" }; var viewModel = this.Container.Resolve <InvestigationOverviewViewModel>(new { Context = context, }); viewModel.Init(); var currentUser = this.UserFacade.GetUser("testuser"); this.InvestigationFacade.FillDataSet(viewModel.Helper.Items, viewModel.Helper.Filter, currentUser); viewModel.RemoveInvestigation(viewModel.Helper.Items.Items.First().Id); using (var uow = this.UnitOfWorkProvider.Create()) { var ctx = EntityFrameworkUnitOfWork.TryGetDbContext <NetfoxWebDbContext>(this.UnitOfWorkProvider); Assert.AreEqual(ctx.Investigations.Count(), 0); } }
public async Task Commit_UOWHasChild_CallCommitCore() { Func <DbContext> dbContextFactory = () => new Mock <DbContext>().Object; var unitOfWorkRegistryStub = new ThreadLocalUnitOfWorkRegistry(); var unitOfWorkProvider = new EntityFrameworkUnitOfWorkProvider(unitOfWorkRegistryStub, dbContextFactory); var unitOfWorkParentMock = new Mock <EntityFrameworkUnitOfWork>(unitOfWorkProvider, dbContextFactory, DbContextOptions.ReuseParentContext) { CallBase = true }; using (var unitOfWorkParent = unitOfWorkParentMock.Object) { unitOfWorkRegistryStub.RegisterUnitOfWork(unitOfWorkParent); using (var unitOfWorkChild = new EntityFrameworkUnitOfWork(unitOfWorkProvider, dbContextFactory, DbContextOptions.ReuseParentContext)) { await unitOfWorkChild.CommitAsync(); } await unitOfWorkParent.CommitAsync(); } unitOfWorkParentMock.Protected().Verify("CommitAsyncCore", Times.Once(), new CancellationToken()); }
public static void SyncCollectionByKey <TDbContext, TSource, TSourceItem, TDestination, TDestinationItem, TKey> ( this IMemberConfigurationExpression <TSource, TDestination, ICollection <TDestinationItem> > config, IEntityFrameworkUnitOfWorkProvider <TDbContext> unitOfWorkProvider, Expression <Func <TSource, ICollection <TSourceItem> > > sourceCollectionSelector, Func <TSourceItem, TKey> sourceKeySelector, Func <TDestinationItem, TKey> destinationKeySelector, Func <TSourceItem, TDestinationItem> createFunction = null, Action <TSourceItem, TDestinationItem> updateFunction = null, Action <TDestinationItem> removeFunction = null, Func <TDestinationItem, bool> destinationFilter = null, bool keepRemovedItemsInDestinationCollection = true ) where TDbContext : DbContext where TDestinationItem : class { if (removeFunction == null) { removeFunction = d => { var uow = EntityFrameworkUnitOfWork.TryGetDbContext(unitOfWorkProvider); uow.Set <TDestinationItem>().Remove(d); }; } Extensions.SyncCollectionByKey(config, sourceCollectionSelector, sourceKeySelector, destinationKeySelector, createFunction, updateFunction, removeFunction, keepRemovedItemsInDestinationCollection, destinationFilter); }
public void CanApplySortedQuery() { using (var unitOfWork = new EntityFrameworkUnitOfWork(new TestDbContext())) { var allFishes = unitOfWork.Repository.Query<Fish>().OrderBy(x => x.Color).ToList(); var queryFishes = unitOfWork.Repository.IsSatisfiedBy(new SearchFishSortedSpecification("Na", "Color", true)).ToList(); queryFishes.Count.Should().Be.EqualTo(allFishes.Count); for (var i = 0; i < queryFishes.Count; i++) { var fish = allFishes.ElementAt(i); var queryFish = queryFishes.ElementAt(i); fish.Name.Should().Be.EqualTo(queryFish.Name); fish.Color.Should().Be.EqualTo(queryFish.Color); fish.Should().Be.EqualTo(queryFish); } allFishes = unitOfWork.Repository.Query<Fish>().OrderByDescending(x => x.Color).ToList(); queryFishes = unitOfWork.Repository.IsSatisfiedBy(new SearchFishSortedSpecification("Na", "Color", false)).ToList(); queryFishes.Count.Should().Be.EqualTo(allFishes.Count); for (var i = 0; i < queryFishes.Count; i++) { var fish = allFishes.ElementAt(i); var queryFish = queryFishes.ElementAt(i); fish.Name.Should().Be.EqualTo(queryFish.Name); fish.Color.Should().Be.EqualTo(queryFish.Color); fish.Should().Be.EqualTo(queryFish); } } }
public async Task CanApplySortedQuery() { using (var unitOfWork = new EntityFrameworkUnitOfWork(new TestDbContext())) { var allFishes = (await unitOfWork.Repository.QueryAsync <Fish>()).OrderBy(x => x.Color).ToList(); var queryFishes = (await unitOfWork.Repository.IsSatisfiedByAsync(new SearchFishSortedSpecification("Na", "Color", true))).ToList(); queryFishes.Count.Should().Be.EqualTo(allFishes.Count); for (var i = 0; i < queryFishes.Count; i++) { var fish = allFishes.ElementAt(i); var queryFish = queryFishes.ElementAt(i); fish.Name.Should().Be.EqualTo(queryFish.Name); fish.Color.Should().Be.EqualTo(queryFish.Color); fish.Should().Be.EqualTo(queryFish); } allFishes = (await unitOfWork.Repository.QueryAsync <Fish>()).OrderByDescending(x => x.Color).ToList(); queryFishes = (await unitOfWork.Repository.IsSatisfiedByAsync(new SearchFishSortedSpecification("Na", "Color", false))).ToList(); queryFishes.Count.Should().Be.EqualTo(allFishes.Count); for (var i = 0; i < queryFishes.Count; i++) { var fish = allFishes.ElementAt(i); var queryFish = queryFishes.ElementAt(i); fish.Name.Should().Be.EqualTo(queryFish.Name); fish.Color.Should().Be.EqualTo(queryFish.Color); fish.Should().Be.EqualTo(queryFish); } } }
public static void SyncCollectionByKey <TDbContext, TSource, TSourceItem, TDestination, TDestinationItem> ( this IMemberConfigurationExpression <TSource, TDestination, ICollection <TDestinationItem> > config, IEntityFrameworkUnitOfWorkProvider <TDbContext> unitOfWorkProvider, Expression <Func <TSource, ICollection <TSourceItem> > > sourceCollectionSelector, Func <TSourceItem, TDestinationItem> createFunction = null, Action <TSourceItem, TDestinationItem> updateFunction = null, Action <TDestinationItem> removeFunction = null, Func <TDestinationItem, bool> destinationFilter = null, bool keepRemovedItemsInDestinationCollection = true ) where TDbContext : DbContext where TDestinationItem : class { if (removeFunction == null) { removeFunction = d => { var dbContext = EntityFrameworkUnitOfWork.TryGetDbContext(unitOfWorkProvider); dbContext.Set <TDestinationItem>().Remove(d); }; } var sourceKeyEntityType = typeof(TSourceItem).GetTypeInfo() .GetInterfaces() .Select(s => s.GetTypeInfo()) .SingleOrDefault(s => s.IsGenericType && s.GetGenericTypeDefinition() == typeof(IEntity <>)); var sourceKeyType = sourceKeyEntityType?.GetGenericArguments()[0]; var destinationKeyEntityType = typeof(TDestinationItem).GetTypeInfo() .GetInterfaces() .Select(s => s.GetTypeInfo()) .SingleOrDefault(s => s.IsGenericType && s.GetGenericTypeDefinition() == typeof(IEntity <>)); var destinationKeyType = destinationKeyEntityType?.GetGenericArguments()[0]; if (sourceKeyType == null || destinationKeyType == null || sourceKeyType != destinationKeyType) { throw new InvalidOperationException( "The source and destination collection items must implement the IEntity<TKey> interface and the keys must be equal!"); } var sourceParam = Expression.Parameter(typeof(TSourceItem), "i"); var sourceKeySelector = Expression.Lambda(Expression.Property(sourceParam, nameof(IEntity <int> .Id)), sourceParam); var destinationParam = Expression.Parameter(typeof(TDestinationItem), "i"); var destinationKeySelector = Expression.Lambda(Expression.Property(destinationParam, nameof(IEntity <int> .Id)), destinationParam); var method = typeof(Extensions).GetTypeInfo().GetMethod("SyncCollectionByKeyReflectionOnly", BindingFlags.NonPublic | BindingFlags.Static); method.MakeGenericMethod(typeof(TSource), typeof(TSourceItem), typeof(TDestination), typeof(TDestinationItem), sourceKeyType) .Invoke(null, new object[] { config, sourceCollectionSelector, sourceKeySelector, destinationKeySelector, createFunction, updateFunction, removeFunction, keepRemovedItemsInDestinationCollection, destinationFilter }); }
static void Run(Action <EntityFrameworkUnitOfWork, Mock <DbContext> > action, bool isOpen = true) { var isolationLevel = IsolationLevel.ReadCommitted; var dbContext = Pleasure.Mock <DbContext>(); var unitOfWork = new EntityFrameworkUnitOfWork(dbContext.Object, isolationLevel, true); action(unitOfWork, dbContext); }
public void UnitOfWorkSaveViaContext() { var unitOfWork = new EntityFrameworkUnitOfWork(_mockContext.Object); unitOfWork.Save(); _mockContext.Verify(m => m.SaveChanges(), Times.Once); }
public virtual void Clean() { using (var uow = this.UnitOfWorkProvider.Create()) { var ctx = EntityFrameworkUnitOfWork.TryGetDbContext <NetfoxWebDbContext>(this.UnitOfWorkProvider); ctx.Database.Delete(); } }
public async Task UnitOfWorkSaveAsyncViaContext() { var unitOfWork = new EntityFrameworkUnitOfWork(_mockContext.Object); await unitOfWork.SaveAsync(); _mockContext.Verify(m => m.SaveChangesAsync(), Times.Once); }
public static IPublishCommands GetCommandPublisher() { var unitOfWork = new EntityFrameworkUnitOfWork(ContextFactory); IPublishCommands commandPublisher = new CommandPublisher(unitOfWork, currentUserSession); commandPublisher.Subscribe(new ClientService(unitOfWork)); return commandPublisher; }
public static IPublishCommands GetCommandPublisher() { var commandPublisher = new LocalCommandPublisher(); var unitOfWork = new EntityFrameworkUnitOfWork(ContextFactory); commandPublisher.Subscribe(new ClientService(unitOfWork, Logger)); return(commandPublisher); }
public static IPublishCommands GetCommandPublisher() { var commandPublisher = new CommandPublisher(); var unitOfWork = new EntityFrameworkUnitOfWork(ContextFactory); commandPublisher.Subscribe(new ClientService(unitOfWork, Logger)); return commandPublisher; }
public void Dispose() { if (this.TransactionScope != null) { (this.TransactionScope as IDisposable).Dispose(); this.TransactionScope = null; this.UnitOfWork = null; } }
public override async Task Invoke( IIncomingLogicalMessageContext context, Func <Task> next) { var uow = new EntityFrameworkUnitOfWork(); context.Extensions.Set(uow); await next(); context.Extensions.Remove <EntityFrameworkUnitOfWork>(); }
public EntityFrameworkRepository(IUnitOfWork unitOfWork) { var entityFrameworkUnitOfWork = unitOfWork as EntityFrameworkUnitOfWork; if (entityFrameworkUnitOfWork == null) { throw new ArgumentOutOfRangeException("Must be of type EntityFrameworkUnitOfWork"); } this.unitOfWork = entityFrameworkUnitOfWork; }
public static IPublishCommands GetCommandPublisher() { var unitOfWork = new EntityFrameworkUnitOfWork(ContextFactory); IPublishCommands commandPublisher = new CommandPublisher(unitOfWork, currentUserSession); commandPublisher.Subscribe(new ClientService(unitOfWork)); return(commandPublisher); }
public void CanQuery() { using (var unitOfWork = new EntityFrameworkUnitOfWork(new TestDbContext())) { var countFish = unitOfWork.Repository.Query <Fish>().Count(); var countCat = unitOfWork.Repository.Query <Cat>().Count(); countFish.Should().Be.EqualTo(5); countCat.Should().Be.EqualTo(10); } }
public async Task CanQuery() { using (var unitOfWork = new EntityFrameworkUnitOfWork(new TestDbContext())) { var countFish = (await unitOfWork.Repository.QueryAsync <Fish>()).Count(); var countCat = (await unitOfWork.Repository.QueryAsync <Cat>()).Count(); countFish.Should().Be.EqualTo(5); countCat.Should().Be.EqualTo(10); } }
public void TestMethod2() { var dbContext = new DanwuDbContext(); var context = new EntityFrameworkRepositoryContext(); var unitOfWork = new EntityFrameworkUnitOfWork(dbContext); IUserRepository userRepository = new UserRepository(context); var users = userRepository.QueryAll(); //users=userRepository.QueryBy( }
public void TryGetDbContext_UnitOfWorkRegistryHasNotUnitOfWork_ReturnsNull() { var dbContext = new Mock <DbContext>().Object; Func <DbContext> dbContextFactory = () => dbContext; var unitOfWorkRegistryStub = new ThreadLocalUnitOfWorkRegistry(); var unitOfWorkProvider = new EntityFrameworkUnitOfWorkProvider(unitOfWorkRegistryStub, dbContextFactory); var value = EntityFrameworkUnitOfWork.TryGetDbContext(unitOfWorkProvider); Assert.Null(value); }
public static IPublishCommands GetCommandPublisher() { var unitOfWork = new EntityFrameworkUnitOfWork(ContextFactory); var authorizer = new CommandAuthorizer(currentUserSession); var commandRetry = new PublishRetry(); IPublishCommands commandPublisher = new CommandPublisher(unitOfWork, authorizer, commandRetry); commandPublisher.Subscribe(new ClientService(unitOfWork)); return commandPublisher; }
public void CanAdd() { using (var unitOfWork = new EntityFrameworkUnitOfWork(new TestDbContext())) { var countFish = unitOfWork.Repository.Query<Fish>().Count(); unitOfWork.Repository.Add(new Fish()); unitOfWork.Commit(); var newCountFish = unitOfWork.Repository.Query<Fish>().Count(); newCountFish.Should().Be.EqualTo(countFish + 1); } }
public void CanRemove() { using (var unitOfWork = new EntityFrameworkUnitOfWork(new TestDbContext())) { var countFish = unitOfWork.Repository.Query <Fish>().Count(); unitOfWork.Repository.Remove(unitOfWork.Repository.Query <Fish>().First()); unitOfWork.Commit(); var newCountFish = unitOfWork.Repository.Query <Fish>().Count(); newCountFish.Should().Be.EqualTo(countFish - 1); } }
public static IPublishCommands GetCommandPublisher() { var proxy = new CommandPublisherProxy(currentUserSession); var retryDecorator = new CommandPublisherRetryDecorator(proxy); var commandPublisher = new CommandPublisherLoggerDecorator(retryDecorator, new ConsoleWindowLogger()); var unitOfWork = new EntityFrameworkUnitOfWork(ContextFactory); commandPublisher.Subscribe(new ClientService(unitOfWork)); return commandPublisher; }
public override void Initialize() { base.Initialize(); var context = Factory.Get(); Uow = new EntityFrameworkUnitOfWork(Factory); AlunoRepository = new AlunoRepositoryEF(Factory); TurmaRepository = new TurmaRepositoryEF(Factory); AulaRepository = new AulaRepositoryEF(Factory); }
public void Execute_InvokesSaveChanges_OnDbContext() { var context = EntityFrameworkMockHelper.GetMockContext <FakeDbContext>(); context.Setup(x => x.SaveChanges()).Returns(1); var unitOfWork = new EntityFrameworkUnitOfWork(() => context.Object); unitOfWork.Execute(); context.Verify(x => x.SaveChanges(), Times.Once); }
public void TestEditDataUser() { this.Configuration.RouteTable.Add("Settings_UserManagement", "settings/User_management", "article.dothtml", null); var context = new TestDotvvmRequestContext() { Configuration = this.Configuration, ApplicationHostPath = "../Netfox.Web.App/", Parameters = new Dictionary <string, object>() }; this.UserFacade.Save(new UserDTO() { Firstname = "test", IsEnable = true, Username = "******", Surname = "test", RoleId = this.AdminRoleID }, "testpass"); var userId = new Guid(); using (var uow = this.UnitOfWorkProvider.Create()) { var ctx = EntityFrameworkUnitOfWork.TryGetDbContext <NetfoxWebDbContext>(this.UnitOfWorkProvider); userId = ctx.Users.First().Id; } context.Parameters.Add("UserId", userId); var viewModel = this.Container.Resolve <UserViewModel>(new { Context = context, }); try { viewModel.UserId = userId; viewModel.Init(); viewModel.PreRender(); viewModel.User.IsEnable = false; viewModel.User.Surname = "test2"; viewModel.Save(); } catch (DotvvmInterruptRequestExecutionException ex) { Assert.AreEqual(InterruptReason.Redirect, ex.InterruptReason); Assert.AreEqual(ex.CustomData, "~/settings/User_management"); using (var uow = this.UnitOfWorkProvider.Create()) { var ctx = EntityFrameworkUnitOfWork.TryGetDbContext <NetfoxWebDbContext>(this.UnitOfWorkProvider); var passHash = this.UserFacade.LoginFacade.SHA256Hash("testpass"); Assert.AreEqual(ctx.Users.Count(u => u.Surname == "test2" && u.Firstname == "test" && u.Username == "testuser" && !u.IsEnable && u.Password == passHash), 1); } return; } Assert.Fail("A redirect should have been performed!"); }
public static IPublishCommands GetCommandPublisher() { var unitOfWork = new EntityFrameworkUnitOfWork(ContextFactory); IPublishCommands commandPublisher = new CommandPublisherProxy(); commandPublisher = new CommandPublisherAuthorizer(commandPublisher, currentUserSession); commandPublisher = new CommandRequestLogger(commandPublisher, currentUserSession, typeof(NewRequest)); commandPublisher = new CommandLogger(commandPublisher); commandPublisher = new CommandRetry(commandPublisher); commandPublisher.Subscribe(new ClientService(unitOfWork)); return commandPublisher; }
public async Task CanApplyQuery() { using (var unitOfWork = new EntityFrameworkUnitOfWork(new TestDbContext())) { var countFish = (await unitOfWork.Repository.QueryAsync <Fish>()).Count(); var queryFish = (await unitOfWork.Repository.IsSatisfiedByAsync(new SearchFishSpecification("Na"))).ToList(); queryFish.Count.Should().Be.EqualTo(countFish); queryFish = (await unitOfWork.Repository.IsSatisfiedByAsync(new SearchFishSpecification(string.Empty))).ToList(); queryFish.Count.Should().Be.EqualTo(countFish); queryFish = (await unitOfWork.Repository.IsSatisfiedByAsync(new SearchFishSpecification("notexistingname"))).ToList(); queryFish.Count.Should().Be.EqualTo(0); } }
public void CanApplyQuery() { using (var unitOfWork = new EntityFrameworkUnitOfWork(new TestDbContext())) { var countFish = unitOfWork.Repository.Query <Fish>().Count(); var queryFish = unitOfWork.Repository.ApplyQuery(new SearchFishQuery("Na")).ToList(); queryFish.Count.Should().Be.EqualTo(countFish); queryFish = unitOfWork.Repository.ApplyQuery(new SearchFishQuery("")).ToList(); queryFish.Count.Should().Be.EqualTo(countFish); queryFish = unitOfWork.Repository.ApplyQuery(new SearchFishQuery("notexistingname")).ToList(); queryFish.Count.Should().Be.EqualTo(0); } }
public async Task CanRemove() { using (var unitOfWork = new EntityFrameworkUnitOfWork(new TestDbContext())) { var countFish = (await unitOfWork.Repository.QueryAsync <Fish>()).Count(); await unitOfWork.Repository.RemoveAsync((await unitOfWork.Repository.QueryAsync <Fish>()).First()); await unitOfWork.CommitAsync(); var newCountFish = (await unitOfWork.Repository.QueryAsync <Fish>()).Count(); newCountFish.Should().Be.EqualTo(countFish - 1); } }
public void CanUpdate() { using (var unitOfWork = new EntityFrameworkUnitOfWork(new TestDbContext())) { var fish = unitOfWork.Repository.Query <Fish>().First(); fish.Name.Should().Not.Be.EqualTo("NewName"); fish.Name = "NewName"; unitOfWork.Repository.Update(fish); unitOfWork.Commit(); var updatedFish = unitOfWork.Repository.Query <Fish>().First(x => x.Id == fish.Id); updatedFish.Name.Should().Be.EqualTo("NewName"); } }
public void CanApplyQuery() { using (var unitOfWork = new EntityFrameworkUnitOfWork(new TestDbContext())) { var countFish = unitOfWork.Repository.Query<Fish>().Count(); var queryFish = unitOfWork.Repository.IsSatisfiedBy(new SearchFishSpecification("Na")).ToList(); queryFish.Count.Should().Be.EqualTo(countFish); queryFish = unitOfWork.Repository.IsSatisfiedBy(new SearchFishSpecification("")).ToList(); queryFish.Count.Should().Be.EqualTo(countFish); queryFish = unitOfWork.Repository.IsSatisfiedBy(new SearchFishSpecification("notexistingname")).ToList(); queryFish.Count.Should().Be.EqualTo(0); } }
public void Map(IMapperConfigurationExpression cfg) { cfg.CreateMap <User, UserDTO>(); cfg.CreateMap <User, PublicProfileDTO>() .BeforeMap((s, d) => { // EF Core does not support lazy loading yet EntityFrameworkUnitOfWork.TryGetDbContext(uowProvider) .Entry(s) .Collection(x => x.WatchedAreas) .Load(); EntityFrameworkUnitOfWork.TryGetDbContext(uowProvider) .Entry(s) .Collection(x => x.WatchedTags) .Load(); }) .ForMember(e => e.WatchedAreaIds, m => m.MapFrom(e => e.WatchedAreas.Select(a => a.AreaId))) .ForMember(e => e.WatchedTagIds, m => m.MapFrom(e => e.WatchedTags.Select(a => a.TagId))); cfg.CreateMap <PublicProfileDTO, User>() .BeforeMap((s, d) => { // EF Core does not support lazy loading yet EntityFrameworkUnitOfWork.TryGetDbContext(uowProvider).Entry(d).Collection(x => x.WatchedAreas).Load(); EntityFrameworkUnitOfWork.TryGetDbContext(uowProvider).Entry(d).Collection(x => x.WatchedTags).Load(); }) .ForMember(e => e.WatchedAreas, m => m.DropAndCreateCollection(uowProvider, x => x.WatchedAreaIds, x => new UserArea { AreaId = x })) .ForMember(e => e.WatchedTags, m => m.DropAndCreateCollection(uowProvider, x => x.WatchedTagIds, x => new UserTag { TagId = x })) .ForMember(e => e.DateCreated, m => m.Ignore()) .ForMember(e => e.DateLastLogin, m => m.Ignore()) .ForMember(e => e.Enabled, m => m.Ignore()) .ForMember(e => e.Id, m => m.Ignore()) .ForMember(e => e.UserName, m => m.Ignore()) .ForMember(e => e.NormalizedUserName, m => m.Ignore()) .ForMember(e => e.Email, m => m.Ignore()) .ForMember(e => e.NormalizedEmail, m => m.Ignore()) .ForMember(e => e.EmailConfirmed, m => m.Ignore()) .ForMember(e => e.PasswordHash, m => m.Ignore()) .ForMember(e => e.SecurityStamp, m => m.Ignore()) .ForMember(e => e.ConcurrencyStamp, m => m.Ignore()) .ForMember(e => e.PhoneNumber, m => m.Ignore()) .ForMember(e => e.PhoneNumberConfirmed, m => m.Ignore()) .ForMember(e => e.TwoFactorEnabled, m => m.Ignore()) .ForMember(e => e.LockoutEnd, m => m.Ignore()) .ForMember(e => e.LockoutEnabled, m => m.Ignore()) .ForMember(e => e.AccessFailedCount, m => m.Ignore()); cfg.CreateMap <User, UserBasicDTO>(); }
static void Run(Action <EntityFrameworkUnitOfWork, Mock <DbContext> > action, bool isOpen = true) { var dbContext = Pleasure.Mock <DbContext>(); string connectionString = ConfigurationManager.ConnectionStrings["IncRealEFDb"].ConnectionString; var sessionFactory = Pleasure.MockStrictAsObject <IEntityFrameworkSessionFactory>(mock => mock.Setup(r => r.Open(connectionString)).Returns(dbContext.Object)); var unitOfWork = new EntityFrameworkUnitOfWork(sessionFactory, IsolationLevel.ReadCommitted, connectionString); if (isOpen) { unitOfWork.Open(); } action(unitOfWork, dbContext); }
public static IPublishCommands GetCommandPublisher() { AsbaBankContext context = new AsbaBankContext("ASBA"); if (!context.Database.Exists()) { context.Database.Create(); } else { context.Database.Delete(); context.Database.Create(); } var commandPublisher = new LocalCommandPublisher(); var unitOfWork = new EntityFrameworkUnitOfWork(context); commandPublisher.Subscribe(new ClientService(unitOfWork, Logger)); return commandPublisher; }
public void SetUp() { _context = Substitute.For<DbContext>(); _sut = new EntityFrameworkUnitOfWork(_context); }
public static ClientService GetClientService() { var unitOfWork = new EntityFrameworkUnitOfWork(ContextFactory); return new ClientService(unitOfWork, Logger); }
public QueueFactory(EntityFrameworkUnitOfWork unitOfWork) { this.unitOfWork = unitOfWork; }
public void TestMethod1() { var uow = new EntityFrameworkUnitOfWork(new CoreDataContext()); uow.GetDbSet<Item>(); }
public void CanUpdate() { using (var unitOfWork = new EntityFrameworkUnitOfWork(new TestDbContext())) { var fish = unitOfWork.Repository.Query<Fish>().First(); fish.Name.Should().Not.Be.EqualTo("NewName"); fish.Name = "NewName"; unitOfWork.Repository.Update(fish); unitOfWork.Commit(); var updatedFish = unitOfWork.Repository.Query<Fish>().First(x => x.Id == fish.Id); updatedFish.Name.Should().Be.EqualTo("NewName"); } }
public void CanQuery() { using (var unitOfWork = new EntityFrameworkUnitOfWork(new TestDbContext())) { var countFish = unitOfWork.Repository.Query<Fish>().Count(); var countCat = unitOfWork.Repository.Query<Cat>().Count(); countFish.Should().Be.EqualTo(5); countCat.Should().Be.EqualTo(10); } }
public QueueStore(EntityFrameworkUnitOfWork unitOfWork) { this.unitOfWork = unitOfWork; }
public static void Seed(EntityFrameworkUnitOfWork context) { }
public EntityFrameworkTransaction(EntityFrameworkUnitOfWork unitOfWork) { this.UnitOfWork = unitOfWork; this.TransactionScope = new TransactionScope(); }