public void DefinitionString() { DefaultTransactionDefinition def = new DefaultTransactionDefinition(); DefaultTransactionDefinition def2 = new DefaultTransactionDefinition(); Assert.IsTrue( def.ToString() == def2.ToString()); def.Equals(def2); }
public void VanillaTest() { DefaultTransactionDefinition def = new DefaultTransactionDefinition( TransactionPropagation.NotSupported); Assert.IsTrue( def.PropagationBehavior == TransactionPropagation.NotSupported ); def.PropagationBehavior = TransactionPropagation.Nested; Assert.IsTrue( def.PropagationBehavior == TransactionPropagation.Nested ); def.TransactionIsolationLevel = IsolationLevel.ReadCommitted; Assert.IsTrue( def.TransactionIsolationLevel == IsolationLevel.ReadCommitted); def.TransactionTimeout = 1000; Assert.IsTrue( 1000 == def.TransactionTimeout ); Assert.IsTrue( false == def.ReadOnly ); def.ReadOnly = true; Assert.IsTrue( true == def.ReadOnly ); }
public void DefinitionStringFilled() { DefaultTransactionDefinition def = new DefaultTransactionDefinition( TransactionPropagation.Never ); def.TransactionIsolationLevel = IsolationLevel.Chaos; def.TransactionTimeout = 1000; def.ReadOnly = true; Assert.AreEqual( "PROPAGATION_Never,ISOLATION_Chaos,timeout_1000,readOnly", def.ToString()); DefaultTransactionDefinition def2 = new DefaultTransactionDefinition( TransactionPropagation.Never ); def2.TransactionIsolationLevel = IsolationLevel.Chaos; def2.TransactionTimeout = 1000; def2.ReadOnly = true; Assert.IsTrue( def2.Equals(def)); Assert.IsTrue( def.GetHashCode() == def2.GetHashCode()); }
public void ExecuteScriptTransactedRollsbackIfNoCommit() { IDbProvider dbProvider = (IDbProvider) mocks.CreateMock(typeof(IDbProvider)); IDbConnection dbConnection = (IDbConnection) mocks.CreateMock(typeof (IDbConnection)); IDbTransaction dbTx = (IDbTransaction) mocks.CreateMock(typeof (IDbTransaction)); DefaultTransactionDefinition txDefinition = new DefaultTransactionDefinition(); Expect.Call(dbProvider.CreateConnection()).Return(dbConnection); dbConnection.Open(); Expect.Call(dbConnection.BeginTransaction(txDefinition.TransactionIsolationLevel)).Return(dbTx); dbTx.Rollback(); dbConnection.Dispose(); mocks.ReplayAll(); AdoTemplate adoOps = new AdoTemplate(dbProvider); IPlatformTransaction tx = SimpleAdoTestUtils.CreateTransaction(dbProvider, txDefinition); tx.Dispose(); mocks.VerifyAll(); }
public void InvalidTimeout() { DefaultTransactionDefinition def = new DefaultTransactionDefinition(); Assert.Throws <ArgumentException>(() => def.TransactionTimeout = -1000); }
/// <summary> /// Return a currently active transaction or create a new one. /// </summary> /// <remarks> /// <p> /// This implementation handles propagation behavior. /// </p> /// <p> /// Delegates to /// <see cref="Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>, /// <see cref="Spring.Transaction.Support.AbstractPlatformTransactionManager.IsExistingTransaction"/>, /// and /// <see cref="Spring.Transaction.Support.AbstractPlatformTransactionManager.DoBegin"/>. /// </p> /// <p> /// Note that parameters like isolation level or timeout will only be applied /// to new transactions, and thus be ignored when participating in active ones. /// Furthermore, they aren't supported by every transaction manager: /// a proper implementation should throw an exception when custom values /// that it doesn't support are specified. /// </p> /// </remarks> /// <param name="definition"> /// <see cref="Spring.Transaction.ITransactionDefinition"/> instance (can be null for /// defaults), describing propagation behavior, isolation level, timeout etc. /// </param> /// <exception cref="Spring.Transaction.TransactionException"> /// In case of lookup, creation, or system errors. /// </exception> /// <returns> /// <see cref="Spring.Transaction.ITransactionStatus"/> representing the new or current transaction. /// </returns> public ITransactionStatus GetTransaction(ITransactionDefinition definition) { object transaction = DoGetTransaction(); bool debugEnabled = log.IsDebugEnabled; if (debugEnabled) { log.Debug("Using transaction object [" + transaction + "]"); } if (definition == null) { definition = new DefaultTransactionDefinition(); } if (IsExistingTransaction(transaction)) { // Existing transaction found -> check propagation behavior to find out how to behave. return HandleExistingTransaction(definition, transaction, debugEnabled); } // Check definition settings for new transaction. if (definition.TransactionTimeout < DefaultTransactionDefinition.TIMEOUT_DEFAULT) { throw new InvalidTimeoutException("Invalid transaction timeout", definition.TransactionTimeout); } // No existing transaction found -> check propagation behavior to find out how to proceed. if (definition.PropagationBehavior == TransactionPropagation.Mandatory) { throw new IllegalTransactionStateException( "Transaction propagation 'mandatory' but no existing transaction found"); } else if (definition.PropagationBehavior == TransactionPropagation.Required || definition.PropagationBehavior == TransactionPropagation.RequiresNew || definition.PropagationBehavior == TransactionPropagation.Nested) { object suspendedResources = Suspend(null); if (debugEnabled) { log.Debug("Creating new transaction with name [" + definition.Name + "]:" + definition); } try { bool newSynchronization = (_transactionSyncState != TransactionSynchronizationState.Never); DefaultTransactionStatus status = NewTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, suspendedResources); DoBegin(transaction, definition); PrepareSynchronization(status, definition); return status; } catch (TransactionException) { Resume(null, suspendedResources); throw; } } else { // Create "empty" transaction: no actual transaction, but potentially synchronization. bool newSynchronization = (_transactionSyncState == TransactionSynchronizationState.Always); return PrepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null); } }
/// <summary>The get transaction.</summary> /// <param name="definition">The definition.</param> /// <returns>The Spring.Transaction.ITransactionStatus.</returns> public ITransactionStatus GetTransaction(ITransactionDefinition definition) { var transaction = this.DoGetTransaction(); // Cache debug flag to avoid repeated checks. var debugEnabled = Logger.IsDebugEnabled; if (definition == null) { // Use defaults if no transaction definition given. definition = new DefaultTransactionDefinition(); } if (this.IsExistingTransaction(transaction)) { // Existing transaction found -> check propagation behavior to find out how to behave. return this.HandleExistingTransaction(definition, transaction, debugEnabled); } // Check definition settings for new transaction. if (definition.TransactionTimeout < -1) { throw new InvalidTimeoutException("Invalid transaction timeout", definition.TransactionTimeout); } // No existing transaction found -> check propagation behavior to find out how to proceed. if (definition.PropagationBehavior == TransactionPropagation.Mandatory) { throw new IllegalTransactionStateException("No existing transaction found for transaction marked with propagation 'mandatory'"); } else if (definition.PropagationBehavior == TransactionPropagation.Required || definition.PropagationBehavior == TransactionPropagation.RequiresNew || definition.PropagationBehavior == TransactionPropagation.Nested) { var suspendedResources = this.Suspend(null); if (debugEnabled) { Logger.Debug("Creating new transaction with name [" + definition.Name + "]: " + definition); } try { var newSynchronization = this.transactionSynchronization != TransactionSynchronizationState.Never; var status = this.NewTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, suspendedResources); this.DoBegin(transaction, definition); this.PrepareSynchronization(status, definition); return status; } catch (Exception ex) { this.Resume(null, suspendedResources); throw ex; } } else { // Create "empty" transaction: no actual transaction, but potentially synchronization. var newSynchronization = this.transactionSynchronization == TransactionSynchronizationState.Always; return this.PrepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null); } }
public void IsolationLevelDefault() { DefaultTransactionDefinition def = new DefaultTransactionDefinition(); Assert.IsTrue(def.TransactionIsolationLevel == IsolationLevel.ReadCommitted); }
public void ExecuteScriptTransactedSuccess() { IDbProvider dbProvider = (IDbProvider) mocks.DynamicMock(typeof(IDbProvider)); IDbConnection dbConnection = mocks.StrictMock<IDbConnection>(); IDbTransaction dbTx = mocks.StrictMock<IDbTransaction>(); IDbCommand dbCommand = mocks.StrictMock<IDbCommand>(); DefaultTransactionDefinition txDefinition = new DefaultTransactionDefinition(); Expect.Call(dbProvider.CreateConnection()).Return(dbConnection); dbConnection.Open(); Expect.Call(dbConnection.BeginTransaction(txDefinition.TransactionIsolationLevel)).Return(dbTx); Expect.Call(dbProvider.CreateCommand()).Return(dbCommand); dbCommand.Connection = dbConnection; dbCommand.Transaction = dbTx; dbCommand.CommandText = "simple sql cmd"; dbCommand.CommandType = CommandType.Text; Expect.Call(dbCommand.ExecuteNonQuery()).Return(0); dbTx.Commit(); dbCommand.Dispose(); dbConnection.Dispose(); mocks.ReplayAll(); AdoTemplate adoOps = new AdoTemplate(dbProvider); IPlatformTransaction tx = SimpleAdoTestUtils.CreateTransaction(dbProvider, txDefinition); SimpleAdoTestUtils.ExecuteSqlScript(adoOps, "simple sql cmd"); tx.Commit(); tx.Dispose(); mocks.VerifyAll(); }
public void PropogationBehaviorDefault() { DefaultTransactionDefinition def = new DefaultTransactionDefinition(); Assert.IsTrue( def.PropagationBehavior == TransactionPropagation.Required ); }
public void IsolationLevelDefault() { DefaultTransactionDefinition def = new DefaultTransactionDefinition(); Assert.IsTrue(def.TransactionIsolationLevel == IsolationLevel.Unspecified); }
public void InvalidTimeout() { DefaultTransactionDefinition def = new DefaultTransactionDefinition(); def.TransactionTimeout = -1000; }
public void ExecuteTransactionManager() { DefaultTransactionDefinition def = new DefaultTransactionDefinition(); def.PropagationBehavior = TransactionPropagation.Required; ITransactionStatus status = transactionManager.GetTransaction(def); ITestObjectDao dao = (ITestObjectDao)ctx["NHTestObjectDao"]; TestObject to; try { to = dao.FindByName("Gabriel"); } catch (Exception) { transactionManager.Rollback(status); throw; } transactionManager.Commit(status); Assert.IsNotNull(to,"FindByName for Gabriel should not return null"); Assert.AreEqual("Gabriel", to.Name); }
public void IsolationLeveNonDefaultl() { DefaultTransactionDefinition def = new DefaultTransactionDefinition(); Assert.IsTrue(def.PropagationBehavior == TransactionPropagation.Required); }
public void ExecuteTransactionManager() { DefaultTransactionDefinition def = new DefaultTransactionDefinition(); def.PropagationBehavior = TransactionPropagation.Required; ITransactionStatus status = transactionManager.GetTransaction(def); int iCount = 0; try { iCount = (int)adoOperations.ExecuteScalar(CommandType.Text, "SELECT COUNT(*) FROM TestObjects"); /* IAdoCommand cmd = new AdoCommand(dbProvider, CommandType.Text); cmd.CommandText = "SELECT COUNT(*) FROM TestObjects"; iCount = (int)cmd.ExecuteScalar(); */ //other AdoCommands can be executed within same tx. } catch (Exception e) { transactionManager.Rollback(status); throw e; } transactionManager.Commit(status); Assert.AreEqual(2, iCount); }
public void PropogationBehaviorDefault() { DefaultTransactionDefinition def = new DefaultTransactionDefinition(); Assert.IsTrue(def.PropagationBehavior == TransactionPropagation.Required); }
/** * Parse a "transactional" element and configure the "transactionManager" and "transactionDefinition" * properties for the target builder. */ private static void ConfigureTransactionAttributes(XmlElement txElement, ObjectDefinitionBuilder targetBuilder) { targetBuilder.AddPropertyReference("transactionManager", txElement.GetAttribute("transaction-manager")); DefaultTransactionDefinition txDefinition = new DefaultTransactionDefinition(); txDefinition.PropagationBehavior = (TransactionPropagation)Enum.Parse(typeof(TransactionPropagation), txElement.GetAttribute("propagation")); txDefinition.TransactionIsolationLevel = (IsolationLevel)Enum.Parse(typeof(IsolationLevel), txElement.GetAttribute("isolation")); txDefinition.TransactionTimeout = Convert.ToInt32(txElement.GetAttribute("timeout")); txDefinition.ReadOnly = txElement.GetAttribute("read-only").Equals("true", StringComparison.OrdinalIgnoreCase); targetBuilder.AddPropertyValue("transactionDefinition", txDefinition); }
public void InvalidTimeout() { DefaultTransactionDefinition def = new DefaultTransactionDefinition(); Assert.Throws<ArgumentException>(() => def.TransactionTimeout = -1000); }