|
From: Mark P. <mar...@us...> - 2007-11-28 05:55:02
|
Update of /cvsroot/springnet/Spring.Net/test/Spring/Spring.Data.Tests/Data In directory sc8-pr-cvs8.sourceforge.net:/tmp/cvs-serv23657/Data Modified Files: AdoPlatformTransactionManagerTests.cs Log Message: SPRNET-776 - Unit tests for AdoPlatformTransactionManager update docs to reflect limitations of AdoPlatformTransactionManager for nested transactions. code cleanup in AdoTemplate, ConnectionUtils Index: AdoPlatformTransactionManagerTests.cs =================================================================== RCS file: /cvsroot/springnet/Spring.Net/test/Spring/Spring.Data.Tests/Data/AdoPlatformTransactionManagerTests.cs,v retrieving revision 1.5 retrieving revision 1.6 diff -C2 -d -r1.5 -r1.6 *** AdoPlatformTransactionManagerTests.cs 12 Nov 2007 19:58:13 -0000 1.5 --- AdoPlatformTransactionManagerTests.cs 28 Nov 2007 05:54:56 -0000 1.6 *************** *** 23,30 **** --- 23,34 ---- using System; using System.Data; + using System.Threading; using NUnit.Framework; using Rhino.Mocks; + using Spring.Dao; using Spring.Data.Common; using Spring.Data.Core; + using Spring.Data.Support; + using Spring.Support; using Spring.Transaction; using Spring.Transaction.Support; *************** *** 35,39 **** { /// <summary> ! /// This calss contains tests for /// </summary> /// <author>Mark Pollack</author> --- 39,43 ---- { /// <summary> ! /// This class contains tests for AdoPlatformTransactionManager /// </summary> /// <author>Mark Pollack</author> *************** *** 50,58 **** } ! // todo test tx sync calls. [Test] public void TransactionCommit() { IDbProvider dbProvider = (IDbProvider) mocks.CreateMock(typeof (IDbProvider)); IDbConnection connection = (IDbConnection) mocks.CreateMock(typeof (IDbConnection)); --- 54,70 ---- } ! [TearDown] ! public void TearDown() ! { ! Assert.IsTrue(TransactionSynchronizationManager.ResourceDictionary.Count == 0); ! Assert.IsFalse(TransactionSynchronizationManager.SynchronizationActive); ! Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly); ! Assert.IsFalse(TransactionSynchronizationManager.ActualTransactionActive); ! } [Test] public void TransactionCommit() { + #region Mock setup IDbProvider dbProvider = (IDbProvider) mocks.CreateMock(typeof (IDbProvider)); IDbConnection connection = (IDbConnection) mocks.CreateMock(typeof (IDbConnection)); *************** *** 71,74 **** --- 83,88 ---- } + #endregion + mocks.ReplayAll(); *************** *** 91,94 **** --- 105,110 ---- public void TransactionRollback() { + #region Mock Setup + IDbProvider dbProvider = (IDbProvider) mocks.CreateMock(typeof (IDbProvider)); IDbConnection connection = (IDbConnection) mocks.CreateMock(typeof (IDbConnection)); *************** *** 107,110 **** --- 123,129 ---- connection.Dispose(); } + + #endregion + mocks.ReplayAll(); *************** *** 388,395 **** --- 407,1182 ---- public void PropagationNeverWithExistingTransaction() { + #region Mock Setup + IDbProvider dbProvider = (IDbProvider)mocks.CreateMock(typeof(IDbProvider)); + IDbConnection connection = (IDbConnection)mocks.CreateMock(typeof(IDbConnection)); + IDbTransaction transaction = (IDbTransaction)mocks.CreateMock(typeof(IDbTransaction)); + + using (mocks.Ordered()) + { + Expect.Call(dbProvider.CreateConnection()).Return(connection); + connection.Open(); + LastCall.On(connection).Repeat.Once(); + Expect.Call(connection.BeginTransaction(IsolationLevel.Unspecified)).Return(transaction); + //standard tx timeout. + transaction.Rollback(); + LastCall.On(transaction).Repeat.Once(); + + connection.Dispose(); + } + #endregion + + mocks.ReplayAll(); + + AdoPlatformTransactionManager tm = new AdoPlatformTransactionManager(dbProvider); + TransactionTemplate tt = new TransactionTemplate(tm); + tt.PropagationBehavior = TransactionPropagation.RequiresNew; + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + Assert.IsTrue(!TransactionSynchronizationManager.SynchronizationActive, "Synchronizations not active"); + + try + { + tt.Execute(new PropagationNeverWithExistingTransactionCallback(tt)); + Assert.Fail("Should have thrown IllegalTransactionStateException"); + } catch (IllegalTransactionStateException) + { + //expected. + } + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + + mocks.VerifyAll(); + } + + [Test] + public void PropagationRequiresNewWithExistingConnection() + { + #region Mock Setup + + IDbProvider dbProvider = (IDbProvider)mocks.CreateMock(typeof(IDbProvider)); + IDbConnection connection = (IDbConnection)mocks.CreateMock(typeof(IDbConnection)); + IDbTransaction transaction = (IDbTransaction)mocks.CreateMock(typeof(IDbTransaction)); + + Expect.Call(dbProvider.CreateConnection()).Return(connection); + connection.Open(); + LastCall.On(connection).Repeat.Once(); + connection.Dispose(); + + IDbConnection connection2 = (IDbConnection)mocks.CreateMock(typeof(IDbConnection)); + IDbTransaction transaction2 = (IDbTransaction)mocks.CreateMock(typeof(IDbTransaction)); + + Expect.Call(dbProvider.CreateConnection()).Return(connection2); + connection2.Open(); + LastCall.On(connection2).Repeat.Once(); + Expect.Call(connection2.BeginTransaction(IsolationLevel.Unspecified)).Return(transaction2); + transaction2.Commit(); + LastCall.On(transaction2).Repeat.Once(); + connection2.Dispose(); + + #endregion + + mocks.ReplayAll(); + + AdoPlatformTransactionManager tm = new AdoPlatformTransactionManager(dbProvider); + TransactionTemplate tt = new TransactionTemplate(tm); + tt.PropagationBehavior = TransactionPropagation.Supports; + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + Assert.IsTrue(!TransactionSynchronizationManager.SynchronizationActive, "Synchronizations not active"); + + tt.Execute(new PropagationRequiresNewWithExistingConnectionCallback(tt, connection, connection2, dbProvider)); + + + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + + mocks.VerifyAll(); + } + + [Test] + public void TransactionWithIsolation() + { + #region Mock setup + IDbProvider dbProvider = (IDbProvider)mocks.CreateMock(typeof(IDbProvider)); + IDbConnection connection = (IDbConnection)mocks.CreateMock(typeof(IDbConnection)); + IDbTransaction transaction = (IDbTransaction)mocks.CreateMock(typeof(IDbTransaction)); + + using (mocks.Ordered()) + { + Expect.Call(dbProvider.CreateConnection()).Return(connection); + connection.Open(); + LastCall.On(connection).Repeat.Once(); + Expect.Call(connection.BeginTransaction(IsolationLevel.Serializable)).Return(transaction); + //standard tx timeout. + transaction.Commit(); + LastCall.On(transaction).Repeat.Once(); + connection.Dispose(); + } + + #endregion + + mocks.ReplayAll(); + + AdoPlatformTransactionManager tm = new AdoPlatformTransactionManager(dbProvider); + TransactionTemplate tt = new TransactionTemplate(tm); + tt.PropagationBehavior = TransactionPropagation.RequiresNew; + tt.TransactionIsolationLevel = IsolationLevel.Serializable; + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + + tt.Execute(new TransactionCommitTxCallback(dbProvider)); + + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + + mocks.VerifyAll(); + } + + [Test] + public void TransactionWithLongTimeout() + { + DoTransactionWithTimeout(10); + } + + [Test] + public void TransactionWithShortTimeout() + { + DoTransactionWithTimeout(1); + } + + private void DoTransactionWithTimeout(int timeout) + { + #region Mock setup + + IDbProvider dbProvider = (IDbProvider)mocks.CreateMock(typeof(IDbProvider)); + IDbConnection connection = (IDbConnection)mocks.CreateMock(typeof(IDbConnection)); + IDbTransaction transaction = (IDbTransaction)mocks.CreateMock(typeof(IDbTransaction)); + IDbCommand command = (IDbCommand) mocks.CreateMock(typeof (IDbCommand)); + + using (mocks.Ordered()) + { + Expect.Call(dbProvider.CreateConnection()).Return(connection); + connection.Open(); + + LastCall.On(connection).Repeat.Once(); + Expect.Call(connection.BeginTransaction(IsolationLevel.Unspecified)).Return(transaction); + Expect.Call(connection.CreateCommand()).Return(command); + command.CommandText = "some SQL statement"; + LastCall.On(command).Repeat.Once(); + if (timeout > 1) + { + command.CommandTimeout = (timeout - 1); + transaction.Commit(); + } else + { + transaction.Rollback(); + } + LastCall.On(transaction).Repeat.Once(); + connection.Dispose(); + } + + #endregion + + mocks.ReplayAll(); + + AdoPlatformTransactionManager tm = new AdoPlatformTransactionManager(dbProvider); + TransactionTemplate tt = new TransactionTemplate(tm); + tt.TransactionTimeout = timeout; + + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + + try + { + tt.Execute(new TransactionWithTimeoutCallback(dbProvider)); + if (timeout <= 1) + { + Assert.Fail("Should have thrown TransactionTimedOutException"); + } + } catch (TransactionTimedOutException) + { + if (timeout <=1 ) + { + //expected + } else + { + throw; + } + } + + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + + mocks.VerifyAll(); + } + + [Test] + public void TransactionWithExceptionOnBegin() + { + #region Mock setup + IDbProvider dbProvider = (IDbProvider)mocks.CreateMock(typeof(IDbProvider)); + + // CreateConnection is called in AdoPlatformTransactionManager.DoBegin + Expect.Call(dbProvider.CreateConnection()).Throw(new TestSqlException("Cannot begin", "314")); + + + #endregion + + mocks.ReplayAll(); + + AdoPlatformTransactionManager tm = new AdoPlatformTransactionManager(dbProvider); + TransactionTemplate tt = new TransactionTemplate(tm); + try + { + tt.Execute(new TransactionDelegate(TransactionWithExceptionNoOp)); + } catch (CannotCreateTransactionException) + { + // expected + } + + + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + + mocks.VerifyAll(); + } + + private object TransactionWithExceptionNoOp(ITransactionStatus status) + { + return null; + } + + [Test] + public void TransactionWithExceptionOnCommit() + { + #region Mock setup + IDbProvider dbProvider = (IDbProvider)mocks.CreateMock(typeof(IDbProvider)); + IDbConnection connection = (IDbConnection)mocks.CreateMock(typeof(IDbConnection)); + IDbTransaction transaction = (IDbTransaction)mocks.CreateMock(typeof(IDbTransaction)); + + using (mocks.Ordered()) + { + Expect.Call(dbProvider.CreateConnection()).Return(connection); + connection.Open(); + LastCall.On(connection).Repeat.Once(); + Expect.Call(connection.BeginTransaction(IsolationLevel.Unspecified)).Return(transaction); + //standard tx timeout. + transaction.Commit(); + LastCall.On(transaction).Throw(new TestSqlException("Cannot commit", "314")); + connection.Dispose(); + } + + #endregion + + mocks.ReplayAll(); + + AdoPlatformTransactionManager tm = new AdoPlatformTransactionManager(dbProvider); + TransactionTemplate tt = new TransactionTemplate(tm); + + try + { + tt.Execute(new TransactionDelegate(TransactionWithExceptionNoOp)); + } catch (TransactionSystemException) + { + //expected + } + + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + mocks.VerifyAll(); } + + + [Test] + public void TransactionWithExceptionOnCommitAndRollbackOnCommitFailure() + { + #region Mock Setup + IDbProvider dbProvider = (IDbProvider)mocks.CreateMock(typeof(IDbProvider)); + IDbConnection connection = (IDbConnection)mocks.CreateMock(typeof(IDbConnection)); + IDbTransaction transaction = (IDbTransaction)mocks.CreateMock(typeof(IDbTransaction)); + + using (mocks.Ordered()) + { + Expect.Call(dbProvider.CreateConnection()).Return(connection); + connection.Open(); + LastCall.On(connection).Repeat.Once(); + Expect.Call(connection.BeginTransaction(IsolationLevel.Unspecified)).Return(transaction); + transaction.Commit(); + LastCall.On(transaction).Throw(new TestSqlException("Cannot commit", "314")); + + transaction.Rollback(); + LastCall.On(transaction).Repeat.Once(); + + connection.Dispose(); + } + #endregion + mocks.ReplayAll(); + + AdoPlatformTransactionManager tm = new AdoPlatformTransactionManager(dbProvider); + tm.RollbackOnCommitFailure = true; + TransactionTemplate tt = new TransactionTemplate(tm); + + try + { + tt.Execute(new TransactionDelegate(TransactionWithExceptionNoOp)); + } + catch (TransactionSystemException) + { + //expected + } + + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + + mocks.VerifyAll(); + } + + [Test] + public void TransactionWithExceptionOnRollback() + { + #region Mock Setup + + IDbProvider dbProvider = (IDbProvider)mocks.CreateMock(typeof(IDbProvider)); + IDbConnection connection = (IDbConnection)mocks.CreateMock(typeof(IDbConnection)); + IDbTransaction transaction = (IDbTransaction)mocks.CreateMock(typeof(IDbTransaction)); + + using (mocks.Ordered()) + { + Expect.Call(dbProvider.CreateConnection()).Return(connection); + connection.Open(); + LastCall.On(connection).Repeat.Once(); + Expect.Call(connection.BeginTransaction(IsolationLevel.Unspecified)).Return(transaction); + //standard tx timeout. + transaction.Rollback(); + LastCall.On(transaction).Throw(new TestSqlException("Cannot commit", "314")); + + connection.Dispose(); + } + + #endregion + + mocks.ReplayAll(); + + AdoPlatformTransactionManager tm = new AdoPlatformTransactionManager(dbProvider); + TransactionTemplate tt = new TransactionTemplate(tm); + + try + { + tt.Execute(new TransactionDelegate(TransactionWithExceptionOnRollbackMethod)); + } + catch (TransactionSystemException) + { + //expected + } + + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + + mocks.VerifyAll(); + + } + + private object TransactionWithExceptionOnRollbackMethod(ITransactionStatus status) + { + status.RollbackOnly = true; + return null; + } + + [Test] + public void TransactionWithPropagationSupports() + { + IDbProvider dbProvider = (IDbProvider)mocks.CreateMock(typeof(IDbProvider)); + + mocks.ReplayAll(); + + AdoPlatformTransactionManager tm = new AdoPlatformTransactionManager(dbProvider); + TransactionTemplate tt = new TransactionTemplate(tm); + tt.PropagationBehavior = TransactionPropagation.Supports; + + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + + tt.Execute(new TransactionWithPropagationSupportsCallback(dbProvider)); + + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + mocks.VerifyAll(); + } + + [Test] + public void TransactionWithPropagationNotSupported() + { + IDbProvider dbProvider = (IDbProvider)mocks.CreateMock(typeof(IDbProvider)); + + mocks.ReplayAll(); + + AdoPlatformTransactionManager tm = new AdoPlatformTransactionManager(dbProvider); + TransactionTemplate tt = new TransactionTemplate(tm); + tt.PropagationBehavior = TransactionPropagation.NotSupported; + + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + + tt.Execute(new TransactionWithPropagationNotSupportedCallback(dbProvider)); + + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + mocks.VerifyAll(); + } + + [Test] + public void TransactionWithPropagationNever() + { + IDbProvider dbProvider = (IDbProvider)mocks.CreateMock(typeof(IDbProvider)); + + mocks.ReplayAll(); + + AdoPlatformTransactionManager tm = new AdoPlatformTransactionManager(dbProvider); + TransactionTemplate tt = new TransactionTemplate(tm); + tt.PropagationBehavior = TransactionPropagation.Never; + + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + + tt.Execute(new TransactionWithPropagationNotSupportedCallback(dbProvider)); + + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + mocks.VerifyAll(); + } + + [Test] + public void ExistingTransactionWithPropagationNestedNotSupported() + { + #region Mock setup + IDbProvider dbProvider = (IDbProvider)mocks.CreateMock(typeof(IDbProvider)); + IDbConnection connection = (IDbConnection)mocks.CreateMock(typeof(IDbConnection)); + IDbTransaction transaction = (IDbTransaction)mocks.CreateMock(typeof(IDbTransaction)); + + using (mocks.Ordered()) + { + Expect.Call(dbProvider.CreateConnection()).Return(connection); + connection.Open(); + LastCall.On(connection).Repeat.Once(); + Expect.Call(connection.BeginTransaction(IsolationLevel.Unspecified)).Return(transaction); + + transaction.Rollback(); + LastCall.On(transaction).Repeat.Once(); + connection.Dispose(); + } + + #endregion + + mocks.ReplayAll(); + + AdoPlatformTransactionManager tm = new AdoPlatformTransactionManager(dbProvider); + TransactionTemplate tt = new TransactionTemplate(tm); + tt.PropagationBehavior = TransactionPropagation.Nested; + + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + Assert.IsTrue(!TransactionSynchronizationManager.SynchronizationActive, "Synchronizations not active"); + + try + { + tt.Execute(new ExistingTransactionWithPropagationNestedCallback(dbProvider, tt)); + Assert.Fail("Should have thrown NestedTransactionNotSupportedException"); + } catch (NestedTransactionNotSupportedException) + { + // expected + } + + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + mocks.VerifyAll(); + } + + [Test] + public void TransactionWithPropagationNested() + { + #region Mock setup + IDbProvider dbProvider = (IDbProvider)mocks.CreateMock(typeof(IDbProvider)); + IDbConnection connection = (IDbConnection)mocks.CreateMock(typeof(IDbConnection)); + IDbTransaction transaction = (IDbTransaction)mocks.CreateMock(typeof(IDbTransaction)); + + using (mocks.Ordered()) + { + Expect.Call(dbProvider.CreateConnection()).Return(connection); + connection.Open(); + LastCall.On(connection).Repeat.Once(); + Expect.Call(connection.BeginTransaction(IsolationLevel.Unspecified)).Return(transaction); + //standard tx timeout. + transaction.Commit(); + LastCall.On(transaction).Repeat.Once(); + connection.Dispose(); + } + + #endregion + + mocks.ReplayAll(); + + AdoPlatformTransactionManager tm = new AdoPlatformTransactionManager(dbProvider); + TransactionTemplate tt = new TransactionTemplate(tm); + + + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + Assert.IsTrue(!TransactionSynchronizationManager.SynchronizationActive, "Synchronizations not active"); + + + tt.Execute(new TransactionDelegate(TransactionWithPropagationNestedMethod)); + + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + mocks.VerifyAll(); + + + } + + private object TransactionWithPropagationNestedMethod(ITransactionStatus status) + { + Assert.IsTrue(status.IsNewTransaction, "Is new transaction"); + return null; + } + + [Test] + public void TransactionWithPropagationNestedAndRollback() + { + #region Mock setup + IDbProvider dbProvider = (IDbProvider)mocks.CreateMock(typeof(IDbProvider)); + IDbConnection connection = (IDbConnection)mocks.CreateMock(typeof(IDbConnection)); + IDbTransaction transaction = (IDbTransaction)mocks.CreateMock(typeof(IDbTransaction)); + + using (mocks.Ordered()) + { + Expect.Call(dbProvider.CreateConnection()).Return(connection); + connection.Open(); + LastCall.On(connection).Repeat.Once(); + Expect.Call(connection.BeginTransaction(IsolationLevel.Unspecified)).Return(transaction); + transaction.Rollback(); + LastCall.On(transaction).Repeat.Once(); + connection.Dispose(); + } + + #endregion + + mocks.ReplayAll(); + + AdoPlatformTransactionManager tm = new AdoPlatformTransactionManager(dbProvider); + TransactionTemplate tt = new TransactionTemplate(tm); + + + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + Assert.IsTrue(!TransactionSynchronizationManager.SynchronizationActive, "Synchronizations not active"); + + + tt.Execute(new TransactionDelegate(TransactionWithPropagationNestedAndRollbackMethod)); + + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(dbProvider), "Hasn't thread db provider"); + mocks.VerifyAll(); + + + } + + private object TransactionWithPropagationNestedAndRollbackMethod(ITransactionStatus status) + { + Assert.IsTrue(status.IsNewTransaction, "Is new transaction"); + status.RollbackOnly = true; + return null; + } } + internal class ExistingTransactionWithPropagationNestedCallback : ITransactionCallback + { + private IDbProvider dbProvider; + private TransactionTemplate tt; + + public ExistingTransactionWithPropagationNestedCallback(IDbProvider dbProvider, TransactionTemplate transactionTemplate) + { + this.dbProvider = dbProvider; + tt = transactionTemplate; + } + + public object DoInTransaction(ITransactionStatus status) + { + Assert.IsTrue(status.IsNewTransaction, "Is new transaction"); + //TODO: Note no support for savepoints at this time (1.1), so can't check that a savepoint isn't present. + + tt.Execute(new ExistingTransactionWithPropagationNestedCallback2(dbProvider)); + + Assert.IsTrue(status.IsNewTransaction, "Is new transaction"); + //TODO: Note no support for savepoints at this time (1.1), so can't check that a savepoint isn't present. + return null; + } + } + + internal class ExistingTransactionWithPropagationNestedCallback2 : ITransactionCallback + { + private IDbProvider dbProvider; + + public ExistingTransactionWithPropagationNestedCallback2(IDbProvider provider) + { + dbProvider = provider; + } + + public object DoInTransaction(ITransactionStatus status) + { + Assert.IsTrue(TransactionSynchronizationManager.HasResource(dbProvider), "Has thread db provider"); + Assert.IsTrue(TransactionSynchronizationManager.SynchronizationActive, "Synchronizations active"); + Assert.IsTrue(!status.IsNewTransaction, "Isn't new transaction"); + //TODO: Note no support for savepoints at this time (1.1), so can't check that a savepoint is present. + return null; + } + } + + #region Supporting class for TransactionWithPropagationNotSupported + internal class TransactionWithPropagationNotSupportedCallback : ITransactionCallback + { + private IDbProvider provider; + + public TransactionWithPropagationNotSupportedCallback(IDbProvider provider) + { + this.provider = provider; + } + + public object DoInTransaction(ITransactionStatus status) + { + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(provider), "Hasn't thread db provider"); + Assert.IsTrue(!status.IsNewTransaction, "Is not new transaction"); + return null; + } + } + #endregion + + #region Supporting class for TransactionWithPropagationSupports + internal class TransactionWithPropagationSupportsCallback : ITransactionCallback + { + private IDbProvider provider; + + public TransactionWithPropagationSupportsCallback(IDbProvider provider) + { + this.provider = provider; + } + + public object DoInTransaction(ITransactionStatus status) + { + Assert.IsTrue(!TransactionSynchronizationManager.HasResource(provider), "Hasn't thread db provider"); + Assert.IsTrue(!status.IsNewTransaction,"Is not new transaction"); + Assert.IsFalse(TransactionSynchronizationManager.CurrentTransactionReadOnly); + Assert.IsFalse(TransactionSynchronizationManager.ActualTransactionActive); + return null; + } + } + #endregion + + + #region Supporting class for TransactionWithTimeout + + internal class TransactionWithTimeoutCallback : ITransactionCallback + { + private IDbProvider provider; + public TransactionWithTimeoutCallback(IDbProvider provider) + { + this.provider = provider; + } + + public object DoInTransaction(ITransactionStatus status) + { + try + { + Thread.Sleep(1500); + } catch (Exception) + { + + } + try + { + IDbConnection con = ConnectionUtils.GetConnection(provider); + IDbCommand cmd = con.CreateCommand(); + cmd.CommandText = "some SQL statement"; + ConnectionUtils.ApplyTransactionTimeout(cmd, provider); + + } catch (Exception e) + { + if (e.GetType() != typeof(TransactionTimedOutException)) + { + throw new DataAccessResourceFailureException("", e); + } + throw; + } + return null; + } + } + #endregion + + #region Supporting class for PropagationRequiresNewWithExistingConnection + + internal class PropagationRequiresNewWithExistingConnectionCallback : ITransactionCallback + { + private TransactionTemplate tt; + private IDbProvider dbProvider; + private IDbConnection connection; + private IDbConnection connection2; + + public PropagationRequiresNewWithExistingConnectionCallback(TransactionTemplate transactionTemplate, IDbConnection connection, IDbConnection connection2, IDbProvider provider) + { + tt = transactionTemplate; + this.connection = connection; + this.connection2 = connection2; + dbProvider = provider; + } + + public object DoInTransaction(ITransactionStatus status) + { + Assert.IsTrue(TransactionSynchronizationManager.SynchronizationActive, "Synchronizations active"); + Assert.AreSame(connection, ConnectionUtils.GetConnection(dbProvider)); + Assert.AreSame(connection, ConnectionUtils.GetConnection(dbProvider)); + tt.PropagationBehavior = TransactionPropagation.RequiresNew; + tt.ReadOnly = true; + tt.Execute(new PropagationRequiresNewWithExistingConnectionCallback2(dbProvider, connection2)); + Assert.AreSame(connection, ConnectionUtils.GetConnection(dbProvider)); + return null; + } + } + + internal class PropagationRequiresNewWithExistingConnectionCallback2 : ITransactionCallback + { + private IDbProvider dbProvider; + private IDbConnection connection2; + + + public PropagationRequiresNewWithExistingConnectionCallback2(IDbProvider dbProvider, IDbConnection connection2) + { + this.dbProvider = dbProvider; + this.connection2 = connection2; + } + + public object DoInTransaction(ITransactionStatus status) + { + Assert.IsTrue(TransactionSynchronizationManager.HasResource(dbProvider), "Has thread db provider"); + Assert.IsTrue(TransactionSynchronizationManager.SynchronizationActive, "Synchronizations active"); + Assert.IsTrue(status.IsNewTransaction, "Is new transaction"); + Assert.AreSame(connection2, ConnectionUtils.GetConnection(dbProvider)); + Assert.AreSame(connection2, ConnectionUtils.GetConnection(dbProvider)); + + return null; + } + } + + #endregion + + #region Supporting classes for PropagationNeverWithExistingTransaction + + internal class PropagationNeverWithExistingTransactionCallback : ITransactionCallback + { + private TransactionTemplate innerTxTemplate; + + public PropagationNeverWithExistingTransactionCallback(TransactionTemplate transactionTemplate) + { + innerTxTemplate = transactionTemplate; + } + + + public object DoInTransaction(ITransactionStatus status) + { + Assert.IsTrue(status.IsNewTransaction, "Is new transaction"); + innerTxTemplate.PropagationBehavior = TransactionPropagation.Never; + innerTxTemplate.Execute(new PropagationNeverWithExistingTransactionCallback2()); + Assert.Fail("Should have thrown IllegalTransactionStateException"); + return null; + } + } + + internal class PropagationNeverWithExistingTransactionCallback2 : ITransactionCallback + { + + public object DoInTransaction(ITransactionStatus status) + { + Assert.Fail("Should have thrown IllegalTransactionStateException"); + return null; + } + } + + #endregion + #region Supporting classes for PropagationNotSupportedWithExistingTransaction *************** *** 541,545 **** public object DoInTransaction(ITransactionStatus status) { ! Assert.IsTrue(TransactionSynchronizationManager.HasResource(provider), "Hasn't thread db provider"); Assert.IsTrue(TransactionSynchronizationManager.SynchronizationActive); Assert.IsTrue(status.IsNewTransaction, "Is new transaction"); --- 1328,1332 ---- public object DoInTransaction(ITransactionStatus status) { ! Assert.IsTrue(TransactionSynchronizationManager.HasResource(provider), "Has thread db provider"); Assert.IsTrue(TransactionSynchronizationManager.SynchronizationActive); Assert.IsTrue(status.IsNewTransaction, "Is new transaction"); *************** *** 622,625 **** --- 1409,1414 ---- #endregion + + #region Helper class |
