// <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;
}
