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