// <summary> // Constructs the DbContextTransaction object with the associated transaction object // </summary> // <param name="transaction">The EntityTransaction object to use</param> internal DbContextTransaction(EntityTransaction transaction) { DebugCheck.NotNull(transaction); _connection = transaction.Connection; EnsureOpenConnection(); _entityTransaction = transaction; }
/// <summary> /// Constructs the DbContextTransaction object with the associated connection object /// and with the given isolation level /// </summary> /// <param name="connection">The EntityConnection object owning this transaction </param> /// <param name="isolationLevel">The database isolation level with which the underlying store transaction will be created</param> internal DbContextTransaction(EntityConnection connection, IsolationLevel isolationLevel) { DebugCheck.NotNull(connection); _connection = connection; EnsureOpenConnection(); _entityTransaction = _connection.BeginTransaction(isolationLevel); }
public void Uses_interception() { var transactionMock = new Mock <DbTransaction>(); transactionMock.Protected().Setup <DbConnection>("DbConnection").Returns(new Mock <DbConnection>().Object); var transaction = new EntityTransaction(new EntityConnection(), transactionMock.Object); var transactionInterceptorMock = new Mock <IDbTransactionInterceptor>(); DbInterception.Add(transactionInterceptorMock.Object); try { transaction.Commit(); } finally { DbInterception.Remove(transactionInterceptorMock.Object); } transactionInterceptorMock.Verify( m => m.Committing(It.IsAny <DbTransaction>(), It.IsAny <DbTransactionInterceptionContext>()), Times.Once()); transactionInterceptorMock.Verify( m => m.Committed(It.IsAny <DbTransaction>(), It.IsAny <DbTransactionInterceptionContext>()), Times.Once()); transactionMock.Verify(m => m.Commit(), Times.Once()); }
public void Uses_interception() { var transactionMock = new Mock <DbTransaction>(); var transaction = new EntityTransaction(new EntityConnection(), transactionMock.Object); var transactionInterceptorMock = new Mock <IDbTransactionInterceptor>(); DbInterception.Add(transactionInterceptorMock.Object); try { Assert.Null(transaction.Connection); } finally { DbInterception.Remove(transactionInterceptorMock.Object); } transactionInterceptorMock.Verify( m => m.ConnectionGetting(It.IsAny <DbTransaction>(), It.IsAny <DbTransactionInterceptionContext <DbConnection> >()), Times.Once()); transactionInterceptorMock.Verify( m => m.ConnectionGot(It.IsAny <DbTransaction>(), It.IsAny <DbTransactionInterceptionContext <DbConnection> >()), Times.Once()); transactionMock.Protected().Verify <DbConnection>("DbConnection", Times.Once()); }
/// <summary> /// Initializes a new instance of the <see cref="T:System.Data.Entity.Core.EntityClient.EntityCommand" /> class with the specified statement, connection and transaction. /// </summary> /// <param name="statement">The text of the command.</param> /// <param name="connection">A connection to the data source.</param> /// <param name="transaction">The transaction in which the command executes.</param> public EntityCommand( string statement, EntityConnection connection, EntityTransaction transaction) : this(statement, connection, transaction, new EntityCommand.EntityDataReaderFactory()) { }
public void Commit_wraps_exceptions() { var transactionMock = new Mock<DbTransaction>(); transactionMock.Setup(m => m.Commit()).Throws<NotImplementedException>(); var transaction = new EntityTransaction(new EntityConnection(), transactionMock.Object); Assert.Throws<EntityException>(() => transaction.Commit()); }
public void Commit_wraps_exceptions() { var transactionMock = new Mock <DbTransaction>(); transactionMock.Setup(m => m.Commit()).Throws <NotImplementedException>(); var transaction = new EntityTransaction(new EntityConnection(), transactionMock.Object); Assert.Throws <EntityException>(() => transaction.Commit()); }
internal EntityCommand( string statement, EntityConnection connection, EntityTransaction transaction, EntityCommand.EntityDataReaderFactory factory) : this(statement, connection, factory) { this._transaction = transaction; }
public void Commit_does_not_wrap_CommitFailedException() { var transactionMock = new Mock <DbTransaction>(); transactionMock.Setup(m => m.Commit()).Throws <CommitFailedException>(); transactionMock.Protected().Setup <DbConnection>("DbConnection").Returns(new Mock <DbConnection>().Object); var transaction = new EntityTransaction(new EntityConnection(), transactionMock.Object); Assert.Throws <CommitFailedException>(() => transaction.Commit()); }
public void Uses_interception() { var transactionMock = new Mock<DbTransaction>(); var transaction = new EntityTransaction(new EntityConnection(), transactionMock.Object); var transactionInterceptorMock = new Mock<IDbTransactionInterceptor>(); DbInterception.Add(transactionInterceptorMock.Object); try { Assert.Equal((IsolationLevel)0, transaction.IsolationLevel); } finally { DbInterception.Remove(transactionInterceptorMock.Object); } transactionInterceptorMock.Verify( m => m.IsolationLevelGetting(It.IsAny<DbTransaction>(), It.IsAny<DbTransactionInterceptionContext<IsolationLevel>>()), Times.Once()); transactionInterceptorMock.Verify( m => m.IsolationLevelGot(It.IsAny<DbTransaction>(), It.IsAny<DbTransactionInterceptionContext<IsolationLevel>>()), Times.Once()); transactionMock.Verify(m => m.IsolationLevel, Times.Once()); }
public void Uses_interception() { var transactionMock = new Mock<DbTransaction>(); var transaction = new EntityTransaction(new EntityConnection(), transactionMock.Object); var transactionInterceptorMock = new Mock<IDbTransactionInterceptor>(); DbInterception.Add(transactionInterceptorMock.Object); try { Assert.Null(transaction.Connection); } finally { DbInterception.Remove(transactionInterceptorMock.Object); } transactionInterceptorMock.Verify( m => m.ConnectionGetting(It.IsAny<DbTransaction>(), It.IsAny<DbTransactionInterceptionContext<DbConnection>>()), Times.Once()); transactionInterceptorMock.Verify( m => m.ConnectionGot(It.IsAny<DbTransaction>(), It.IsAny<DbTransactionInterceptionContext<DbConnection>>()), Times.Once()); transactionMock.Protected().Verify<DbConnection>("DbConnection", Times.Once()); }
public void Uses_interception() { var transactionMock = new Mock <DbTransaction>(); var transaction = new EntityTransaction(new EntityConnection(), transactionMock.Object); var transactionInterceptorMock = new Mock <IDbTransactionInterceptor>(); DbInterception.Add(transactionInterceptorMock.Object); try { Assert.Equal((IsolationLevel)0, transaction.IsolationLevel); } finally { DbInterception.Remove(transactionInterceptorMock.Object); } transactionInterceptorMock.Verify( m => m.IsolationLevelGetting(It.IsAny <DbTransaction>(), It.IsAny <DbTransactionInterceptionContext <IsolationLevel> >()), Times.Once()); transactionInterceptorMock.Verify( m => m.IsolationLevelGot(It.IsAny <DbTransaction>(), It.IsAny <DbTransactionInterceptionContext <IsolationLevel> >()), Times.Once()); transactionMock.Verify(m => m.IsolationLevel, Times.Once()); }
public void Uses_interception() { var transactionMock = new Mock <DbTransaction>(); var transaction = new EntityTransaction(new EntityConnection(), transactionMock.Object); var transactionInterceptorMock = new Mock <IDbTransactionInterceptor>(); DbInterception.Add(transactionInterceptorMock.Object); try { transaction.Dispose(); } finally { DbInterception.Remove(transactionInterceptorMock.Object); } transactionInterceptorMock.Verify( m => m.Disposing(It.IsAny <DbTransaction>(), It.IsAny <DbTransactionInterceptionContext>()), Times.Once()); transactionInterceptorMock.Verify( m => m.Disposed(It.IsAny <DbTransaction>(), It.IsAny <DbTransactionInterceptionContext>()), Times.Once()); transactionMock.Protected().Verify("Dispose", Times.Once(), ItExpr.IsAny <bool>()); }
// <summary> // Clears the current DbTransaction for this connection // </summary> internal virtual void ClearCurrentTransaction() { _currentTransaction = null; }
public void Commit_does_not_wrap_CommitFailedException() { var transactionMock = new Mock<DbTransaction>(); transactionMock.Setup(m => m.Commit()).Throws<CommitFailedException>(); transactionMock.Protected().Setup<DbConnection>("DbConnection").Returns(new Mock<DbConnection>().Object); var transaction = new EntityTransaction(new EntityConnection(), transactionMock.Object); Assert.Throws<CommitFailedException>(() => transaction.Commit()); }
public void Uses_interception() { var transactionMock = new Mock<DbTransaction>(); var transaction = new EntityTransaction(new EntityConnection(), transactionMock.Object); var transactionInterceptorMock = new Mock<IDbTransactionInterceptor>(); DbInterception.Add(transactionInterceptorMock.Object); try { transaction.Dispose(); } finally { DbInterception.Remove(transactionInterceptorMock.Object); } transactionInterceptorMock.Verify( m => m.Disposing(It.IsAny<DbTransaction>(), It.IsAny<DbTransactionInterceptionContext>()), Times.Once()); transactionInterceptorMock.Verify( m => m.Disposed(It.IsAny<DbTransaction>(), It.IsAny<DbTransactionInterceptionContext>()), Times.Once()); transactionMock.Protected().Verify("Dispose", Times.Once(), ItExpr.IsAny<bool>()); }
public void Uses_interception() { var transactionMock = new Mock<DbTransaction>(); transactionMock.Protected().Setup<DbConnection>("DbConnection").Returns(new Mock<DbConnection>().Object); var transaction = new EntityTransaction(new EntityConnection(), transactionMock.Object); var transactionInterceptorMock = new Mock<IDbTransactionInterceptor>(); DbInterception.Add(transactionInterceptorMock.Object); try { transaction.Commit(); } finally { DbInterception.Remove(transactionInterceptorMock.Object); } transactionInterceptorMock.Verify( m => m.Committing(It.IsAny<DbTransaction>(), It.IsAny<DbTransactionInterceptionContext>()), Times.Once()); transactionInterceptorMock.Verify( m => m.Committed(It.IsAny<DbTransaction>(), It.IsAny<DbTransactionInterceptionContext>()), Times.Once()); transactionMock.Verify(m => m.Commit(), Times.Once()); }
/// <summary> /// Given an entity command and entity transaction, passes through relevant state to store provider /// command. /// </summary> /// <param name="entityCommand"> Entity command. Must not be null. </param> /// <param name="entityTransaction"> Entity transaction. Must not be null. </param> /// <param name="storeProviderCommand"> Store provider command that is being setup. Must not be null. </param> internal static void SetStoreProviderCommandState( EntityCommand entityCommand, EntityTransaction entityTransaction, DbCommand storeProviderCommand) { DebugCheck.NotNull(entityCommand); DebugCheck.NotNull(storeProviderCommand); storeProviderCommand.CommandTimeout = entityCommand.CommandTimeout; storeProviderCommand.Connection = (entityCommand.Connection).StoreConnection; storeProviderCommand.Transaction = (null != entityTransaction) ? entityTransaction.StoreTransaction : null; storeProviderCommand.UpdatedRowSource = entityCommand.UpdatedRowSource; }
/// <summary> /// Initializes a new instance of the <see cref="T:System.Data.Entity.Core.EntityClient.EntityCommand" /> class with the specified statement, connection and transaction. /// </summary> /// <param name="statement">The text of the command.</param> /// <param name="connection">A connection to the data source.</param> /// <param name="transaction">The transaction in which the command executes.</param> public EntityCommand(string statement, EntityConnection connection, EntityTransaction transaction) : this(statement, connection, transaction, new EntityDataReaderFactory()) { }
internal EntityCommand( string statement, EntityConnection connection, EntityTransaction transaction, EntityDataReaderFactory factory) : this(statement, connection, factory) { _transaction = transaction; }
/// <summary> /// Begins a database transaction /// </summary> /// <param name="isolationLevel"> The isolation level of the transaction </param> /// <returns> An object representing the new transaction </returns> protected override DbTransaction BeginDbTransaction(IsolationLevel isolationLevel) { if (_fakeConnectionState != null) { return new EntityTransaction(); } if (CurrentTransaction != null) { throw new InvalidOperationException(Strings.EntityClient_TransactionAlreadyStarted); } if (_storeConnection == null) { throw Error.EntityClient_ConnectionStringNeededBeforeOperation(); } if (State != ConnectionState.Open) { throw Error.EntityClient_ConnectionNotOpen(); } var interceptionContext = new BeginTransactionInterceptionContext(InterceptionContext); if (isolationLevel != IsolationLevel.Unspecified) { interceptionContext = interceptionContext.WithIsolationLevel(isolationLevel); } DbTransaction storeTransaction = null; try { var executionStrategy = DbProviderServices.GetExecutionStrategy(_storeConnection, GetMetadataWorkspace()); storeTransaction = executionStrategy.Execute( () => { if (DbInterception.Dispatch.Connection.GetState(_storeConnection, InterceptionContext) == ConnectionState.Broken) { DbInterception.Dispatch.Connection.Close(_storeConnection, interceptionContext); } if (DbInterception.Dispatch.Connection.GetState(_storeConnection, InterceptionContext) == ConnectionState.Closed) { DbInterception.Dispatch.Connection.Open(_storeConnection, interceptionContext); } return DbInterception.Dispatch.Connection.BeginTransaction( _storeConnection, interceptionContext); }); } catch (Exception e) { if (e.IsCatchableExceptionType()) { throw new EntityException(Strings.EntityClient_ErrorInBeginningTransaction, e); } throw; } // The provider is problematic if it succeeded in beginning a transaction but returned a null // for the transaction object if (storeTransaction == null) { throw new ProviderIncompatibleException( Strings.EntityClient_ReturnedNullOnProviderMethod("BeginTransaction", _storeConnection.GetType().Name)); } _currentTransaction = new EntityTransaction(this, storeTransaction); return _currentTransaction; }
// <summary> // Enables the user to pass in a database transaction created outside of the Entity Framework // if you want the framework to execute commands within that external transaction. // Or pass in null to clear the Framework's knowledge of the current transaction. // </summary> // <returns>the EntityTransaction wrapping the DbTransaction or null if cleared</returns> // <exception cref="InvalidOperationException">Thrown if the transaction is already completed</exception> // <exception cref="InvalidOperationException"> // Thrown if the connection associated with the <see cref="Database" /> object is already enlisted in a // <see // cref="System.Transactions.TransactionScope" /> // transaction // </exception> // <exception cref="InvalidOperationException"> // Thrown if the connection associated with the <see cref="Database" /> object is already participating in a transaction // </exception> // <exception cref="InvalidOperationException">Thrown if the connection associated with the transaction does not match the Entity Framework's connection</exception> internal virtual EntityTransaction UseStoreTransaction(DbTransaction storeTransaction) { if (storeTransaction == null) { ClearCurrentTransaction(); } else { if (CurrentTransaction != null) { throw new InvalidOperationException(Strings.DbContext_TransactionAlreadyStarted); } if (EnlistedInUserTransaction) { throw new InvalidOperationException(Strings.DbContext_TransactionAlreadyEnlistedInUserTransaction); } var transactionConnection = DbInterception.Dispatch.Transaction.GetConnection( storeTransaction, InterceptionContext); if (transactionConnection == null) { throw new InvalidOperationException(Strings.DbContext_InvalidTransactionNoConnection); } if (transactionConnection != StoreConnection) { throw new InvalidOperationException(Strings.DbContext_InvalidTransactionForConnection); } _currentTransaction = new EntityTransaction(this, storeTransaction); } return _currentTransaction; }
/// <summary> /// Begins a database transaction /// </summary> /// <param name="isolationLevel">The isolation level of the transaction</param> /// <returns>An object representing the new transaction</returns> protected override DbTransaction BeginDbTransaction(IsolationLevel isolationLevel) { if (CurrentTransaction != null) { throw new InvalidOperationException(Strings.EntityClient_TransactionAlreadyStarted); } if (_storeConnection == null) { throw new InvalidOperationException(Strings.EntityClient_ConnectionStringNeededBeforeOperation); } if (State != ConnectionState.Open) { throw new InvalidOperationException(Strings.EntityClient_ConnectionNotOpen); } DbTransaction storeTransaction = null; try { storeTransaction = _storeConnection.BeginTransaction(isolationLevel); } catch (Exception e) { if (e.IsCatchableExceptionType()) { throw new EntityException(Strings.EntityClient_ErrorInBeginningTransaction, e); } throw; } // The provider is problematic if it succeeded in beginning a transaction but returned a null // for the transaction object if (storeTransaction == null) { throw new ProviderIncompatibleException( Strings.EntityClient_ReturnedNullOnProviderMethod("BeginTransaction", _storeConnection.GetType().Name)); } _currentTransaction = new EntityTransaction(this, storeTransaction); return _currentTransaction; }