public void Cloning_the_interception_context_preserves_contextual_information_but_not_mutable_state()
{
var objectContext = new ObjectContext();
var dbContext = DbContextMockHelper.CreateDbContext(objectContext);
var interceptionContext = new BeginTransactionInterceptionContext();
var mutableData = ((IDbMutableInterceptionContext <DbTransaction>)interceptionContext).MutableData;
var transaction = new Mock <DbTransaction>().Object;
mutableData.SetExecuted(transaction);
mutableData.SetExceptionThrown(new Exception("Cheez Whiz"));
interceptionContext = interceptionContext
.WithDbContext(dbContext)
.WithObjectContext(objectContext)
.WithIsolationLevel(IsolationLevel.RepeatableRead)
.AsAsync();
interceptionContext = new BeginTransactionInterceptionContext(interceptionContext);
Assert.Equal(new[] { objectContext }, interceptionContext.ObjectContexts);
Assert.Equal(new[] { dbContext }, interceptionContext.DbContexts);
Assert.True(interceptionContext.IsAsync);
Assert.Equal(IsolationLevel.RepeatableRead, interceptionContext.IsolationLevel);
Assert.Null(interceptionContext.Result);
Assert.Null(interceptionContext.OriginalResult);
Assert.Null(interceptionContext.Exception);
Assert.Null(interceptionContext.OriginalException);
Assert.False(interceptionContext.IsExecutionSuppressed);
}
/// <summary>
/// Sends <see cref="M:System.Data.Entity.Infrastructure.Interception.IDbConnectionInterceptor.BeginningTransaction(System.Data.Common.DbConnection,System.Data.Entity.Infrastructure.Interception.BeginTransactionInterceptionContext)" /> and
/// <see cref="M:System.Data.Entity.Infrastructure.Interception.IDbConnectionInterceptor.BeganTransaction(System.Data.Common.DbConnection,System.Data.Entity.Infrastructure.Interception.BeginTransactionInterceptionContext)" /> to any <see cref="T:System.Data.Entity.Infrastructure.Interception.IDbConnectionInterceptor" />
/// registered on <see cref="T:System.Data.Entity.Infrastructure.Interception.DbInterception" /> before/after making a
/// call to <see cref="M:System.Data.Common.DbConnection.BeginTransaction(System.Data.IsolationLevel)" />.
/// </summary>
/// <remarks>
/// Note that the result of executing the command is returned by this method. The result is not available
/// in the interception context passed into this method since the interception context is cloned before
/// being passed to interceptors.
/// </remarks>
/// <param name="connection">The connection on which the operation will be executed.</param>
/// <param name="interceptionContext">Optional information about the context of the call being made.</param>
/// <returns>The result of the operation, which may have been modified by interceptors.</returns>
public virtual DbTransaction BeginTransaction(
DbConnection connection,
BeginTransactionInterceptionContext interceptionContext)
{
Check.NotNull <DbConnection>(connection, nameof(connection));
Check.NotNull <BeginTransactionInterceptionContext>(interceptionContext, nameof(interceptionContext));
return(this.InternalDispatcher.Dispatch <DbConnection, BeginTransactionInterceptionContext, DbTransaction>(connection, (Func <DbConnection, BeginTransactionInterceptionContext, DbTransaction>)((t, c) => t.BeginTransaction(c.IsolationLevel)), new BeginTransactionInterceptionContext((DbInterceptionContext)interceptionContext), (Action <IDbConnectionInterceptor, DbConnection, BeginTransactionInterceptionContext>)((i, t, c) => i.BeginningTransaction(t, c)), (Action <IDbConnectionInterceptor, DbConnection, BeginTransactionInterceptionContext>)((i, t, c) => i.BeganTransaction(t, c))));
}
/// <summary>
/// Creates a new <see cref="T:System.Data.Entity.Infrastructure.Interception.BeginTransactionInterceptionContext" /> that contains all the contextual information in this
/// interception context together with the given <see cref="P:System.Data.Entity.Infrastructure.Interception.BeginTransactionInterceptionContext.IsolationLevel" />.
/// </summary>
/// <param name="isolationLevel">The isolation level to associate.</param>
/// <returns>A new interception context associated with the given isolation level.</returns>
public BeginTransactionInterceptionContext WithIsolationLevel(
IsolationLevel isolationLevel)
{
BeginTransactionInterceptionContext interceptionContext = this.TypedClone();
interceptionContext._isolationLevel = isolationLevel;
return(interceptionContext);
}
public void BeganTransaction_logs_exceptions()
{
var writer = new StringWriter();
var interceptionContext = new BeginTransactionInterceptionContext();
interceptionContext.Exception = new Exception("Boo");
new DatabaseLogFormatter(writer.Write).BeganTransaction(new Mock <DbConnection>().Object, interceptionContext);
Assert.True(
_resourceVerifier.IsMatch("TransactionStartErrorLog", GetSingleLine(writer), new AnyValueParameter(), "Boo", ""));
}
/// <summary>
/// Creates a new <see cref="T:System.Data.Entity.Infrastructure.Interception.BeginTransactionInterceptionContext" /> by copying immutable state from the given
/// interception context. Also see <see cref="M:System.Data.Entity.Infrastructure.Interception.BeginTransactionInterceptionContext.Clone" />
/// </summary>
/// <param name="copyFrom">The context from which to copy state.</param>
public BeginTransactionInterceptionContext(DbInterceptionContext copyFrom)
: base(copyFrom)
{
Check.NotNull <DbInterceptionContext>(copyFrom, nameof(copyFrom));
BeginTransactionInterceptionContext interceptionContext = copyFrom as BeginTransactionInterceptionContext;
if (interceptionContext == null)
{
return;
}
this._isolationLevel = interceptionContext._isolationLevel;
}
/// <summary>
/// Sends <see cref="IDbConnectionInterceptor.BeginningTransaction" /> and
/// <see cref="IDbConnectionInterceptor.BeganTransaction" /> to any <see cref="IDbConnectionInterceptor" />
/// registered on <see cref="DbInterception" /> before/after making a
/// call to <see cref="DbConnection.BeginTransaction(IsolationLevel)" />.
/// </summary>
/// <remarks>
/// Note that the result of executing the command is returned by this method. The result is not available
/// in the interception context passed into this method since the interception context is cloned before
/// being passed to interceptors.
/// </remarks>
/// <param name="connection">The connection on which the operation will be executed.</param>
/// <param name="interceptionContext">Optional information about the context of the call being made.</param>
/// <returns>The result of the operation, which may have been modified by interceptors.</returns>
public virtual DbTransaction BeginTransaction(
DbConnection connection, BeginTransactionInterceptionContext interceptionContext)
{
Check.NotNull(connection, "connection");
Check.NotNull(interceptionContext, "interceptionContext");
return(InternalDispatcher.Dispatch(
connection,
(t, c) => t.BeginTransaction(c.IsolationLevel),
new BeginTransactionInterceptionContext(interceptionContext),
(i, t, c) => i.BeginningTransaction(t, c),
(i, t, c) => i.BeganTransaction(t, c)));
}
/// <summary>
/// Sends <see cref="IDbConnectionInterceptor.BeginningTransaction" /> and
/// <see cref="IDbConnectionInterceptor.BeganTransaction" /> to any <see cref="IDbConnectionInterceptor" />
/// registered on <see cref="DbInterception" /> before/after making a
/// call to <see cref="DbConnection.BeginTransaction(IsolationLevel)" />.
/// </summary>
/// <remarks>
/// Note that the result of executing the command is returned by this method. The result is not available
/// in the interception context passed into this method since the interception context is cloned before
/// being passed to interceptors.
/// </remarks>
/// <param name="dbConnection">The connection on which the operation will be executed.</param>
/// <param name="interceptionContext">Optional information about the context of the call being made.</param>
/// <returns>The result of the operation, which may have been modified by interceptors.</returns>
public virtual DbTransaction BeginTransaction(
DbConnection dbConnection, BeginTransactionInterceptionContext interceptionContext)
{
Check.NotNull(dbConnection, "dbConnection");
Check.NotNull(interceptionContext, "interceptionContext");
var clonedInterceptionContext = new BeginTransactionInterceptionContext(interceptionContext);
return(InternalDispatcher.Dispatch(
() => dbConnection.BeginTransaction(clonedInterceptionContext.IsolationLevel),
clonedInterceptionContext,
i => i.BeginningTransaction(dbConnection, clonedInterceptionContext),
i => i.BeganTransaction(dbConnection, clonedInterceptionContext)));
}
public void Initially_has_no_state()
{
var interceptionContext = new BeginTransactionInterceptionContext();
Assert.Empty(interceptionContext.DbContexts);
Assert.Null(interceptionContext.Exception);
Assert.False(interceptionContext.IsAsync);
Assert.False(interceptionContext.IsExecutionSuppressed);
Assert.Equal(IsolationLevel.Unspecified, interceptionContext.IsolationLevel);
Assert.Empty(interceptionContext.ObjectContexts);
Assert.Null(interceptionContext.OriginalException);
Assert.Null(interceptionContext.OriginalResult);
Assert.Null(interceptionContext.Result);
Assert.Equal((TaskStatus)0, interceptionContext.TaskStatus);
}
public void BeginTransaction_executes_operation_and_dispatches_to_interceptors()
{
var mockConnection = new Mock <DbConnection>();
var mockInterceptor = new Mock <IDbConnectionInterceptor>();
var dispatcher = new DbConnectionDispatcher();
var internalDispatcher = dispatcher.InternalDispatcher;
internalDispatcher.Add(mockInterceptor.Object);
var interceptionContext = new BeginTransactionInterceptionContext().WithIsolationLevel(IsolationLevel.Serializable);
dispatcher.BeginTransaction(mockConnection.Object, interceptionContext);
mockConnection.Protected().Verify <DbTransaction>("BeginDbTransaction", Times.Once(), IsolationLevel.Serializable);
mockInterceptor.Verify(m => m.BeginningTransaction(mockConnection.Object, It.IsAny <BeginTransactionInterceptionContext>()), Times.Once());
mockInterceptor.Verify(m => m.BeganTransaction(mockConnection.Object, It.IsAny <BeginTransactionInterceptionContext>()), Times.Once());
}
/// <summary>
/// Called after <see cref="DbConnection.BeginTransaction(Data.IsolationLevel)" /> is invoked.
/// The default implementation of this method filters by <see cref="DbContext" /> set into
/// <see cref="Context" />, if any, and then logs the event.
/// </summary>
/// <param name="connection">The connection that began the transaction.</param>
/// <param name="interceptionContext">Contextual information associated with the call.</param>
public virtual void BeganTransaction(DbConnection connection, BeginTransactionInterceptionContext interceptionContext)
{
Check.NotNull(connection, "connection");
Check.NotNull(interceptionContext, "interceptionContext");
if (Context == null ||
interceptionContext.DbContexts.Contains(Context, ReferenceEquals))
{
if (interceptionContext.Exception != null)
{
Write(Strings.TransactionStartErrorLog(DateTimeOffset.Now, interceptionContext.Exception.Message, Environment.NewLine));
}
else
{
Write(Strings.TransactionStartedLog(DateTimeOffset.Now, Environment.NewLine));
}
}
}
/// <summary>
/// Called after <see cref="M:System.Data.Common.DbConnection.BeginTransaction(System.Data.IsolationLevel)" /> is invoked.
/// The default implementation of this method filters by <see cref="T:System.Data.Entity.DbContext" /> set into
/// <see cref="P:System.Data.Entity.Infrastructure.Interception.DatabaseLogFormatter.Context" />, if any, and then logs the event.
/// </summary>
/// <param name="connection">The connection that began the transaction.</param>
/// <param name="interceptionContext">Contextual information associated with the call.</param>
public virtual void BeganTransaction(
DbConnection connection,
BeginTransactionInterceptionContext interceptionContext)
{
Check.NotNull <DbConnection>(connection, nameof(connection));
Check.NotNull <BeginTransactionInterceptionContext>(interceptionContext, nameof(interceptionContext));
if (this.Context != null && !interceptionContext.DbContexts.Contains <DbContext>(this.Context, new Func <DbContext, DbContext, bool>(object.ReferenceEquals)))
{
return;
}
if (interceptionContext.Exception != null)
{
this.Write(Strings.TransactionStartErrorLog((object)DateTimeOffset.Now, (object)interceptionContext.Exception.Message, (object)Environment.NewLine));
}
else
{
this.Write(Strings.TransactionStartedLog((object)DateTimeOffset.Now, (object)Environment.NewLine));
}
}
/// <summary>
/// Does not write to log unless overridden.
/// </summary>
/// <param name="connection">The connection beginning the transaction.</param>
/// <param name="interceptionContext">Contextual information associated with the call.</param>
public virtual void BeginningTransaction(DbConnection connection, BeginTransactionInterceptionContext interceptionContext)
{
}
public abstract void BeganTransaction(DbConnection connection, BeginTransactionInterceptionContext interceptionContext);