protected void ApplyPropagationBehavior(SimpleServiceConfig serviceConfig, ITransactionDefinition definition)
{
if (definition.PropagationBehavior == TransactionPropagation.Required)
{
serviceConfig.TransactionOption = TransactionOption.Required;
}
else if (definition.PropagationBehavior == TransactionPropagation.RequiresNew)
{
serviceConfig.TransactionOption = TransactionOption.RequiresNew;
}
else if (definition.PropagationBehavior == TransactionPropagation.Supports)
{
serviceConfig.TransactionOption = TransactionOption.Supported;
}
else if (definition.PropagationBehavior == TransactionPropagation.NotSupported)
{
serviceConfig.TransactionOption = TransactionOption.NotSupported;
}
else if (definition.PropagationBehavior == TransactionPropagation.Never)
{
//TODO check the validity of this mapping
serviceConfig.TransactionOption = TransactionOption.Disabled;
}
else
{
//TODO Should we throw an exception instead?
log.Warn("The requested transaction propagation option " +
definition.PropagationBehavior + " is not supported. " +
"Defaulting to Never(Disabled) ");
}
}
public void TransactionCommit()
{
IServiceDomainAdapter txAdapter = A.Fake <IServiceDomainAdapter>();
A.CallTo(() => txAdapter.IsInTransaction).Returns(false).Once().Then.Returns(true).Once();
//ProcessCommit - status.GlobalRollbackOnly check
//DoCommit - status.GlobalRollbackOnly check
//DoCommit - check to call SetComplete or SetAbort
A.CallTo(() => txAdapter.MyTransactionVote).Returns(TransactionVote.Commit).NumberOfTimes(3);
A.CallTo(() => txAdapter.Leave()).Returns(TransactionStatus.Commited).Once();
ServiceDomainPlatformTransactionManager tm = new ServiceDomainPlatformTransactionManager(txAdapter);
TransactionTemplate tt = new TransactionTemplate(tm);
tm.TransactionSynchronization = TransactionSynchronizationState.Always;
tt.Execute(TransactionCommitMethod);
Assert.IsFalse(TransactionSynchronizationManager.SynchronizationActive);
Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly);
SimpleServiceConfig serviceConfig = new SimpleServiceConfig();
ConfigureServiceConfig(serviceConfig, true);
A.CallTo(() => txAdapter.Enter(serviceConfig)).MustHaveHappenedOnceExactly();
A.CallTo(() => txAdapter.SetComplete()).MustHaveHappenedOnceExactly();
}
public void TransactionCommit()
{
#region Mock Setup
IServiceDomainAdapter txAdapter = (IServiceDomainAdapter)mocks.CreateMock(typeof(IServiceDomainAdapter));
using (mocks.Ordered())
{
Expect.Call(txAdapter.IsInTransaction).Return(false);
SimpleServiceConfig serviceConfig = new SimpleServiceConfig();
ConfigureServiceConfig(serviceConfig, true);
txAdapter.Enter(serviceConfig);
//ProcessCommit - status.GlobalRollbackOnly check
Expect.Call(txAdapter.MyTransactionVote).Return(TransactionVote.Commit);
//DoCommit - status.GlobalRollbackOnly check
Expect.Call(txAdapter.MyTransactionVote).Return(TransactionVote.Commit);
Expect.Call(txAdapter.IsInTransaction).Return(true);
//DoCommit - check to call SetComplete or SetAbort
Expect.Call(txAdapter.MyTransactionVote).Return(TransactionVote.Commit);
txAdapter.SetComplete();
Expect.Call(txAdapter.Leave()).Return(TransactionStatus.Commited);
}
#endregion
mocks.ReplayAll();
IPlatformTransactionManager tm = new ServiceDomainPlatformTransactionManager(txAdapter);
TransactionTemplate tt = new TransactionTemplate(tm);
tt.Execute(new TransactionDelegate(TransactionCommitMethod));
Assert.IsFalse(TransactionSynchronizationManager.SynchronizationActive);
Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly);
mocks.VerifyAll();
}
private void DoServiceDomainBegin(ServiceDomainTransactionObject serviceDomainTxObject, ITransactionDefinition definition)
{
SimpleServiceConfig serviceConfig = CreateServiceConfig(definition);
//The context is created when we call Enter.
serviceDomainTxObject.ServiceDomainAdapter.Enter(serviceConfig);
if (log.IsDebugEnabled)
{
log.Debug("Context created. TransactionId = " + ContextUtil.TransactionId
+ ", ActivityId = " + ContextUtil.ActivityId);
}
}
private SimpleServiceConfig ConfigureServiceConfig(SimpleServiceConfig serviceConfig, bool standardIsolationAndProp)
{
serviceConfig.TransactionDescription = null;
serviceConfig.TrackingEnabled = true;
serviceConfig.TrackingAppName = "Spring.NET";
serviceConfig.TrackingComponentName = "ServiceDomainPlatformTransactionManager";
if (standardIsolationAndProp)
{
serviceConfig.TransactionOption = TransactionOption.Required;
serviceConfig.IsolationLevel = TransactionIsolationLevel.ReadCommitted;
}
return(serviceConfig);
}
public void PropagationRequiresNewWithExistingTransaction()
{
#region Mock Setup
IServiceDomainAdapter txAdapter = (IServiceDomainAdapter)mocks.CreateMock(typeof(IServiceDomainAdapter));
using (mocks.Ordered())
{
Expect.Call(txAdapter.IsInTransaction).Return(false);
SimpleServiceConfig serviceConfig = new SimpleServiceConfig();
ConfigureServiceConfig(serviceConfig, true);
txAdapter.Enter(serviceConfig);
Expect.Call(txAdapter.IsInTransaction).Return(true);
// inner tx
ConfigureServiceConfig(serviceConfig, false);
serviceConfig.TransactionOption = TransactionOption.RequiresNew;
serviceConfig.IsolationLevel = TransactionIsolationLevel.ReadCommitted;
txAdapter.Enter(serviceConfig);
Expect.Call(txAdapter.IsInTransaction).Return(true);
txAdapter.SetAbort();
Expect.Call(txAdapter.Leave()).Return(TransactionStatus.Aborted);
// innter tx aborted
//ProcessCommit - status.GlobalRollbackOnly check
Expect.Call(txAdapter.MyTransactionVote).Return(TransactionVote.Commit);
//DoCommit - status.GlobalRollbackOnly check
Expect.Call(txAdapter.MyTransactionVote).Return(TransactionVote.Commit);
Expect.Call(txAdapter.IsInTransaction).Return(true);
//DoCommit - check to call SetComplete or SetAbort
Expect.Call(txAdapter.MyTransactionVote).Return(TransactionVote.Commit);
txAdapter.SetComplete();
Expect.Call(txAdapter.Leave()).Return(TransactionStatus.Commited);
}
#endregion
mocks.ReplayAll();
ServiceDomainPlatformTransactionManager tm = new ServiceDomainPlatformTransactionManager(txAdapter);
tm.TransactionSynchronization = TransactionSynchronizationState.Always;
TransactionTemplate tt = new TransactionTemplate(tm);
tt.PropagationBehavior = TransactionPropagation.RequiresNew;
tt.Execute(new PropagationRequiresNewWithExistingTransactionCallbackSD(tt));
mocks.VerifyAll();
}
protected void ApplyIsolationLevel(SimpleServiceConfig serviceConfig, ITransactionDefinition definition)
{
switch (definition.TransactionIsolationLevel)
{
case System.Data.IsolationLevel.Chaos:
if (log.IsInfoEnabled)
{
log.Info("IsolationLevel Chaos does not have a direct counterpart in EnterpriseServices, using Any");
}
serviceConfig.IsolationLevel = TransactionIsolationLevel.Any;
break;
case System.Data.IsolationLevel.ReadCommitted:
serviceConfig.IsolationLevel = TransactionIsolationLevel.ReadCommitted;
break;
case System.Data.IsolationLevel.ReadUncommitted:
serviceConfig.IsolationLevel = TransactionIsolationLevel.ReadUncommitted;
break;
case System.Data.IsolationLevel.RepeatableRead:
serviceConfig.IsolationLevel = TransactionIsolationLevel.RepeatableRead;
break;
case System.Data.IsolationLevel.Serializable:
serviceConfig.IsolationLevel = TransactionIsolationLevel.Serializable;
break;
#if NET_2_0
case System.Data.IsolationLevel.Snapshot:
if (log.IsInfoEnabled)
{
log.Info("IsolationLevel Snapshot does not have a direct counterpart in EnterpriseServices, using ReadCommitted. Introduced in SqlServer 2005. Consider using System.Transactions for transaction management instead.");
}
serviceConfig.IsolationLevel = TransactionIsolationLevel.ReadCommitted; //err on the side of consistency
break;
#endif
case System.Data.IsolationLevel.Unspecified:
serviceConfig.IsolationLevel = TransactionIsolationLevel.Any;
break;
}
}
public void TransactionRollback()
{
#region Mock Setup
IServiceDomainAdapter txAdapter = (IServiceDomainAdapter)mocks.CreateMock(typeof(IServiceDomainAdapter));
using (mocks.Ordered())
{
Expect.Call(txAdapter.IsInTransaction).Return(false);
SimpleServiceConfig serviceConfig = new SimpleServiceConfig();
ConfigureServiceConfig(serviceConfig, true);
txAdapter.Enter(serviceConfig);
Expect.Call(txAdapter.IsInTransaction).Return(true);
txAdapter.SetAbort();
Expect.Call(txAdapter.Leave()).Return(TransactionStatus.Commited);
}
#endregion
mocks.ReplayAll();
ServiceDomainPlatformTransactionManager tm = new ServiceDomainPlatformTransactionManager(txAdapter);
tm.TransactionSynchronization = TransactionSynchronizationState.Always;
TransactionTemplate tt = new TransactionTemplate(tm);
Assert.IsTrue(!TransactionSynchronizationManager.SynchronizationActive, "Synchronizations not active");
Exception ex = new ArgumentException("test exception");
try
{
tt.Execute(new TransactionRollbackTxCallback(ex));
Assert.Fail("Should have thrown exception");
}
catch (ArgumentException e)
{
Assert.AreEqual(ex, e);
}
Assert.IsTrue(!TransactionSynchronizationManager.SynchronizationActive, "Synchronizations not active");
mocks.VerifyAll();
}
private SimpleServiceConfig CreateServiceConfig(ITransactionDefinition definition)
{
SimpleServiceConfig serviceConfig = new SimpleServiceConfig();
//TODO investigate BringYourOwnTransaction and TipUrl properties of ServiceConfig
serviceConfig.TransactionDescription = definition.Name;
serviceConfig.TrackingEnabled = TrackingEnabled;
serviceConfig.TrackingAppName = TrackingAppName;
serviceConfig.TrackingComponentName = TrackingComponentName;
ApplyPropagationBehavior(serviceConfig, definition);
ApplyIsolationLevel(serviceConfig, definition);
// infinite==-1 would cause transactions to be aborted immediately!
if (definition.TransactionTimeout != Timeout.Infinite)
{
serviceConfig.TransactionTimeout = definition.TransactionTimeout;
}
return(serviceConfig);
}
public void PropagationRequiresNewWithExistingTransaction()
{
IServiceDomainAdapter txAdapter = A.Fake <IServiceDomainAdapter>();
A.CallTo(() => txAdapter.IsInTransaction)
.Returns(false).Once()
.Then.Returns(true).NumberOfTimes(3);
A.CallTo(() => txAdapter.Leave())
.Returns(TransactionStatus.Aborted).Once()
.Then.Returns(TransactionStatus.Commited).Once();
A.CallTo(() => txAdapter.MyTransactionVote).Returns(TransactionVote.Commit).NumberOfTimes(3);
ServiceDomainPlatformTransactionManager tm = new ServiceDomainPlatformTransactionManager(txAdapter);
tm.TransactionSynchronization = TransactionSynchronizationState.Always;
TransactionTemplate tt = new TransactionTemplate(tm);
tt.PropagationBehavior = TransactionPropagation.RequiresNew;
tt.Execute(new PropagationRequiresNewWithExistingTransactionCallbackSD(tt));
SimpleServiceConfig serviceConfig = new SimpleServiceConfig();
ConfigureServiceConfig(serviceConfig, false);
serviceConfig.TransactionOption = TransactionOption.RequiresNew;
serviceConfig.IsolationLevel = TransactionIsolationLevel.ReadCommitted;
A.CallTo(() => txAdapter.Enter(serviceConfig)).MustHaveHappened();
ConfigureServiceConfig(serviceConfig, false);
serviceConfig.TransactionOption = TransactionOption.RequiresNew;
serviceConfig.IsolationLevel = TransactionIsolationLevel.ReadCommitted;
A.CallTo(() => txAdapter.Enter(serviceConfig)).MustHaveHappened();
A.CallTo(() => txAdapter.SetAbort()).MustHaveHappenedOnceExactly();
A.CallTo(() => txAdapter.SetComplete()).MustHaveHappenedOnceExactly();
}
public void TransactionRollback()
{
SimpleServiceConfig serviceConfig = new SimpleServiceConfig();
ConfigureServiceConfig(serviceConfig, standardIsolationAndProp: true);
IServiceDomainAdapter txAdapter = A.Fake <IServiceDomainAdapter>();
A.CallTo(() => txAdapter.IsInTransaction).Returns(false).Once().Then.Returns(true);
A.CallTo(() => txAdapter.Leave()).Returns(TransactionStatus.Commited);
ServiceDomainPlatformTransactionManager tm = new ServiceDomainPlatformTransactionManager(txAdapter);
tm.TransactionSynchronization = TransactionSynchronizationState.Always;
TransactionTemplate tt = new TransactionTemplate(tm);
Assert.IsTrue(!TransactionSynchronizationManager.SynchronizationActive, "Synchronizations not active");
Exception ex = new ArgumentException("test exception");
try
{
tt.Execute(new TransactionRollbackTxCallback(ex));
Assert.Fail("Should have thrown exception");
}
catch (ArgumentException e)
{
Assert.AreEqual(ex, e);
}
Assert.IsTrue(!TransactionSynchronizationManager.SynchronizationActive, "Synchronizations not active");
A.CallTo(() => txAdapter.SetAbort()).MustHaveHappenedOnceExactly();
A.CallTo(() => txAdapter.Enter(serviceConfig)).MustHaveHappenedOnceExactly();
}
