public void Rollback()
{
ITransactionSynchronization sync =
(ITransactionSynchronization)mocks.DynamicMock(typeof(ITransactionSynchronization));
sync.BeforeCompletion();
LastCall.On(sync).Repeat.Once();
sync.AfterCompletion(TransactionSynchronizationStatus.Rolledback);
LastCall.On(sync).Repeat.Once();
mocks.ReplayAll();
TxScopeTransactionManager tm = new TxScopeTransactionManager();
tm.TransactionSynchronization = TransactionSynchronizationState.Always;
TransactionTemplate tt = new TransactionTemplate(tm);
tt.TransactionTimeout = 10;
tt.Name = "txName";
Assert.IsFalse(TransactionSynchronizationManager.SynchronizationActive);
Assert.IsNull(TransactionSynchronizationManager.CurrentTransactionName);
Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly);
tt.Execute(status =>
{
Assert.IsTrue(TransactionSynchronizationManager.SynchronizationActive);
TransactionSynchronizationManager.RegisterSynchronization(sync);
Assert.AreEqual("txName", TransactionSynchronizationManager.CurrentTransactionName);
Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly);
status.SetRollbackOnly();
return(null);
}
);
mocks.VerifyAll();
}
/// <summary>
/// Registers a new <see cref="ITransactionSynchronization"/> to a scope.
/// </summary>
/// <param name="scope">the scope to register the synchronization to</param>
/// <param name="synchronization">the synchronization to register</param>
public static void RegisterTransactionSynchronization(TransactionScope scope, ITransactionSynchronization synchronization)
{
IList <ITransactionSynchronization> scopeSynchronizations;
if (!Synchronizations.TryGetValue(scope, out scopeSynchronizations))
{
scopeSynchronizations = new List <ITransactionSynchronization>();
Synchronizations[scope] = scopeSynchronizations;
}
scopeSynchronizations.Add(synchronization);
}
public void SessionCallbackWithinSynchronizedTransaction()
{
SingleConnectionFactory scf = new SingleConnectionFactory(mockConnectionFactory);
NmsTemplate template = CreateTemplate();
template.ConnectionFactory = scf;
mockConnection.Start();
LastCall.On(mockConnection).Repeat.Times(2);
// We're gonna call getTransacted 3 times, i.e. 2 more times.
Expect.Call(mockSession.Transacted).Return(UseTransactedSession).Repeat.Twice();
if (UseTransactedTemplate)
{
mockSession.Commit();
LastCall.On(mockSession).Repeat.Once();
}
mockSession.Close();
LastCall.On(mockSession).Repeat.Once();
mockConnection.Stop();
LastCall.On(mockConnection).Repeat.Once();
mockConnection.Close();
LastCall.On(mockConnection).Repeat.Once();
mocks.ReplayAll();
TransactionSynchronizationManager.InitSynchronization();
try
{
template.Execute(session =>
{
bool b = session.Transacted;
return(null);
});
template.Execute(session =>
{
bool b = session.Transacted;
return(null);
});
Assert.AreSame(mockSession, ConnectionFactoryUtils.GetTransactionalSession(scf, null, false));
Assert.AreSame(mockSession,
ConnectionFactoryUtils.GetTransactionalSession(scf, scf.CreateConnection(), false));
//In Java this test was doing 'double-duty' and testing TransactionAwareConnectionFactoryProxy, which has
//not been implemented in .NET
template.Execute(session =>
{
bool b = session.Transacted;
return(null);
});
IList synchs = TransactionSynchronizationManager.Synchronizations;
Assert.AreEqual(1, synchs.Count);
ITransactionSynchronization synch = (ITransactionSynchronization)synchs[0];
synch.BeforeCommit(false);
synch.BeforeCompletion();
synch.AfterCommit();
synch.AfterCompletion(TransactionSynchronizationStatus.Unknown);
}
finally
{
TransactionSynchronizationManager.ClearSynchronization();
//Assert.IsTrue(TransactionSynchronizationManager.ResourceDictionary.Count == 0);
//Assert.IsFalse(TransactionSynchronizationManager.SynchronizationActive);
scf.Dispose();
}
Assert.IsTrue(TransactionSynchronizationManager.ResourceDictionary.Count == 0);
mocks.VerifyAll();
}
/**
* Register a new transaction synchronization for the current thread.
* Typically called by resource management code.
* <p>Note that synchronizations can implement the
* {@link org.springframework.core.Ordered} interface.
* They will be executed in an order according to their order value (if any).
* @param synchronization the synchronization object to register
* @throws IllegalStateException if transaction synchronization is not active
* @see org.springframework.core.Ordered
*/
/// <summary>The register synchronization.</summary>
/// <param name="synchronization">The synchronization.</param>
/// <exception cref="InvalidOperationException"></exception>
public static void RegisterSynchronization(ITransactionSynchronization synchronization)
{
AssertUtils.ArgumentNotNull(synchronization, "TransactionSynchronization must not be null");
if (!IsSynchronizationActive())
{
throw new InvalidOperationException("Transaction synchronization is not active");
}
synchronizations.Value.AddOrUpdate(synchronization);
}
/// <summary>
/// Registers a new <see cref="ITransactionSynchronization"/> to a scope.
/// </summary>
/// <param name="scope">the scope to register the synchronization to</param>
/// <param name="synchronization">the synchronization to register</param>
public static void RegisterTransactionSynchronization(TransactionScope scope, ITransactionSynchronization synchronization)
{
IList<ITransactionSynchronization> scopeSynchronizations;
if (!Synchronizations.TryGetValue(scope, out scopeSynchronizations))
{
scopeSynchronizations = new List<ITransactionSynchronization>();
Synchronizations[scope] = scopeSynchronizations;
}
scopeSynchronizations.Add(synchronization);
}
/// <summary>
/// Register a new transaction synchronization for the current thread.
/// </summary>
/// <remarks>
/// Typically called by resource management code.
/// </remarks>
/// <exception cref="System.InvalidOperationException">
/// If synchronization is not active.
/// </exception>
public static void RegisterSynchronization( ITransactionSynchronization synchronization )
{
AssertUtils.ArgumentNotNull(synchronization, "TransactionSynchronization must not be null");
if ( !SynchronizationActive )
{
throw new InvalidOperationException( "Transaction synchronization is not active" );
}
ArrayList syncs = LogicalThreadContext.GetData(syncsDataSlotName) as ArrayList;
if (syncs != null)
{
object root = syncs.SyncRoot;
lock (root)
{
syncs.Add(synchronization);
}
}
}
