public async Task ChildUow_TransactionOperationWillDelayedtoParent_Async()
{
var provider = GetServiceProvider(AddScopeTransactionProvider);
var uowManager = provider.GetService <IUnitOfWorkManager>();
var currentDbExecutor = new ScopeDbExecutor(new FakeDbContext());
using (var uow = uowManager.Create())
{
using (var uow2 = uowManager.Create())
{
await uow2.TryAddDbExecutorAsync(currentDbExecutor);
//当前会具有外围的事务
Assert.True(currentDbExecutor.HasTransaction);
await uow2.SaveChangesAsync();
}
//虽然在uow2之外，但是由于使用了子uow，所以此时也不会被uow2释放
Assert.False(currentDbExecutor.IsDispose);
await uow.SaveChangesAsync();
}
//uow结束，则uow2包含的操作也将释放
Assert.True(currentDbExecutor.IsDispose);
}
public async Task MoreProvider_CannotReused_Async()
{
var provider = GetServiceProvider(AddTwoSameTypeProvider);
var uowManager = provider.GetService <IUnitOfWorkManager>();
var currentDbExecutor = new ScopeDbExecutor(new FakeDbContext());
var currentDbExecutor2 = new DemoDbExecutor(new DemoDbContext());
using (var uow = uowManager.Create())
{
await uow.TryAddDbExecutorAsync(currentDbExecutor);
//此时工作单元中已经有一个事务，但是由于类型不同currentDbExecutor2不能复用
await uow.TryAddDbExecutorAsync(currentDbExecutor2);
Assert.True(currentDbExecutor.HasTransaction);
Assert.False(currentDbExecutor2.HasTransaction);
await uow.SaveChangesAsync();
}
//但是会被添加到工作单元，最后于工作单元一同释放
Assert.True(currentDbExecutor.IsDispose);
Assert.True(currentDbExecutor2.IsDispose);
}
public async Task MoreProvider_CanReused_Async()
{
var provider = GetServiceProvider(AddTwoSameTypeProvider);
var uowManager = provider.GetService <IUnitOfWorkManager>();
var currentDbExecutor = new ScopeDbExecutor(new FakeDbContext());
var currentDbExecutor2 = new ScopeDbExecutor(new FakeDbContext());
using (var uow = uowManager.Create())
{
await uow.TryAddDbExecutorAsync(currentDbExecutor);
//此时工作单元中已经有一个事务，同一类型的执行对象可以复用已有事务
await uow.TryAddDbExecutorAsync(currentDbExecutor2);
Assert.True(currentDbExecutor.HasTransaction);
Assert.True(currentDbExecutor2.HasTransaction);
//currentDbExecutor2的事务来源是上一个事务
var transactionObj = currentDbExecutor2.TransactionObject as TestScopeTransactionObject;
Assert.NotNull(transactionObj);
Assert.Equal("TestScope", transactionObj.Source);
await uow.SaveChangesAsync();
}
//但是会被添加到工作单元，最后于工作单元一同释放
Assert.True(currentDbExecutor.IsDispose);
Assert.True(currentDbExecutor2.IsDispose);
}
public async Task UnitOfWork_NoAnyProvider_DbContextManualDispose_Async()
{
//没有事务支持程序
var provider = GetServiceProvider();
var uowManager = provider.GetService <IUnitOfWorkManager>();
FakeDbContext fakeDbContext;
ScopeDbExecutor fakeDbExecutor;
using (var uow = uowManager.Create())
{
using (var dbContext = new FakeDbContext())
{
fakeDbContext = dbContext;
fakeDbExecutor = new ScopeDbExecutor(dbContext);
await uow.TryAddDbExecutorAsync(fakeDbExecutor);
await uow.SaveChangesAsync();
Assert.False(fakeDbExecutor.HasTransaction);
Assert.False(fakeDbContext.IsDispose);
}
//手动释放了dbcontext;
Assert.True(fakeDbContext.IsDispose);
}
//dbContext还会在工作单元释放时被释放，但是不会报错。
Assert.True(fakeDbContext.IsDispose);
}
public async Task ChildUnitOfWorkEvent_WillTrigger_Async()
{
var provider = GetServiceProvider(AddScopeTransactionProvider);
var uowManager = provider.GetService <IUnitOfWorkManager>();
var currentDbExecutor = new ScopeDbExecutor(new FakeDbContext());
string saveChangedInfo = "";
string rollbackInfo = "";
string disposeInfo = "";
var options = new UnitOfWorkOptions();
options.Events.OnCompleted += s =>
{
saveChangedInfo = "over";
return(Task.CompletedTask);
};
options.Events.OnRollbacked += s =>
{
rollbackInfo = "over";
return(Task.CompletedTask);
};
options.Events.OnDispose += s =>
{
disposeInfo = "over";
return(Task.CompletedTask);
};
using (var uow = uowManager.Create())
{
using (var uow2 = uowManager.Create(options))
{
await uow2.TryAddDbExecutorAsync(currentDbExecutor);
await uow2.SaveChangesAsync();
await uow2.RollbackAsync();
}
}
Assert.Equal("over", saveChangedInfo);
Assert.Equal("over", rollbackInfo);
Assert.Equal("over", disposeInfo);
//uow结束，则uow2包含的操作也将释放
Assert.True(currentDbExecutor.IsDispose);
}
public async Task SuppressOption_ExecutorBeEntrusted_AndNotOpenTransaction_Async()
{
var provider = GetServiceProvider(AddScopeTransactionProvider);
var uowManager = provider.GetService <IUnitOfWorkManager>();
var currentDbExecutor = new ScopeDbExecutor(new FakeDbContext());
using (var uow = uowManager.Create(UnitOfWorkScope.Suppress))
{
await uow.TryAddDbExecutorAsync(currentDbExecutor);
//Provider接受了当前Executor,但是由于Suppress配置，所以不会为该对象开启事务
Assert.False(currentDbExecutor.HasTransaction);
await uow.SaveChangesAsync();
}
Assert.True(currentDbExecutor.IsDispose);
}
public async Task AlreadyHasTransactionExecutor_ShouldNotCreateNewTrsansation_Async()
{
var provider = GetServiceProvider(AddScopeTransactionProvider);
var uowManager = provider.GetService <IUnitOfWorkManager>();
var currentDbExecutor = new ScopeDbExecutor(new FakeDbContext());
//在托管给uow之前就已经具有了事务
var transaScope = new TransactionScope();
await currentDbExecutor.UseTransactionAsync(new TestScopeTransactionObject(transaScope));
using (var uow = uowManager.Create())
{
await uow.TryAddDbExecutorAsync(currentDbExecutor);
await uow.SaveChangesAsync();
}
transaScope.Dispose();//由于是外界的事务，所以uow不会托管该事务，需要手动释放
Assert.True(currentDbExecutor.IsDispose);
}
public async Task MoreProvider_UseSuitableProvider_Async()
{
var provider = GetServiceProvider(AddTwoDifferentTypeProvider);
var uowManager = provider.GetService <IUnitOfWorkManager>();
var currentDbExecutor = new ScopeDbExecutor(new FakeDbContext());
using (var uow = uowManager.Create())
{
await uow.TryAddDbExecutorAsync(currentDbExecutor);
//具有多个Provider，但是它只会接受TestScopeTransactionProvider
Assert.True(currentDbExecutor.HasTransaction);
Assert.IsType <TransactionScope>(currentDbExecutor.DbOjectInstance.Trsansaction);
await uow.SaveChangesAsync();
}
Assert.True(currentDbExecutor.IsDispose);
Assert.Null(Transaction.Current);
}
public void UnitOfWork_NoAnyProvider()
{
//没有事务支持程序
var provider = GetServiceProvider();
var uowManager = provider.GetService <IUnitOfWorkManager>();
var dbContext = new FakeDbContext();
var currentDbExecutor = new ScopeDbExecutor(dbContext);
using (var uow = uowManager.Create())
{
uow.TryAddDbExecutor(currentDbExecutor);
uow.SaveChanges();
Assert.False(currentDbExecutor.HasTransaction);
}
//没有事务提供程序，但是该操作对象还是会被托管释放
Assert.True(currentDbExecutor.IsDispose);
Assert.True(dbContext.IsDispose);
}
public async Task UnitOfWork_OnlyOneProvider_CanCreate_Async()
{
var provider = GetServiceProvider(AddScopeTransactionProvider);
var uowManager = provider.GetService <IUnitOfWorkManager>();
var currentDbExecutor = new ScopeDbExecutor(new FakeDbContext());
using (var uow = uowManager.Create())
{
await uow.TryAddDbExecutorAsync(currentDbExecutor);
//Provider接受了当前Executor,并且开启了事务
Assert.True(currentDbExecutor.HasTransaction);
//使用TransactionScope时，将会开启一个当前事务
Assert.NotNull(Transaction.Current);
await uow.SaveChangesAsync();
}
Assert.True(currentDbExecutor.IsDispose);
Assert.Null(Transaction.Current);
}
public async Task MoreSuitableProvider_UseOrderLowest_Async()
{
var provider = GetServiceProvider(AddTwoSameTypeProvider);
var uowManager = provider.GetService <IUnitOfWorkManager>();
var currentDbExecutor = new ScopeDbExecutor(new FakeDbContext());
using (var uow = uowManager.Create())
{
await uow.TryAddDbExecutorAsync(currentDbExecutor);
//具有多个同类型的Provider，但是它只会接受TestScopeTransactionProvider
var transactionObj = currentDbExecutor.TransactionObject as TestScopeTransactionObject;
Assert.NotNull(transactionObj);
Assert.Equal("TestScope", transactionObj.Source);
await uow.SaveChangesAsync();
}
Assert.True(currentDbExecutor.IsDispose);
Assert.Null(Transaction.Current);
}
