public void ExecuteScalar_should_dispatch_to_interceptor_and_optionally_execute()
{
var mockCommand = new Mock<DbCommand>();
mockCommand.Setup(m => m.ExecuteScalar()).Returns(11);
var mockCancelable = new Mock<ICancelableDbCommandInterceptor>();
var mockPublicInterceptor = new Mock<DbCommandInterceptor> { CallBase = true };
var dispatchers = new Dispatchers();
dispatchers.AddInterceptor(mockCancelable.Object);
dispatchers.AddInterceptor(mockPublicInterceptor.Object);
var context = new Mock<InternalContextForMock>().Object.Owner;
var interceptionContext = new DbInterceptionContext().WithDbContext(context);
var interceptableDbCommand = new InterceptableDbCommand(mockCommand.Object, interceptionContext, dispatchers);
mockCancelable.Setup(m => m.CommandExecuting(mockCommand.Object, It.IsAny<DbInterceptionContext>())).Returns(false);
interceptableDbCommand.ExecuteScalar();
mockCommand.Verify(m => m.ExecuteScalar(), Times.Never());
mockCancelable.Verify(m => m.CommandExecuting(mockCommand.Object, interceptionContext), Times.Once());
mockPublicInterceptor.Verify(
m => m.ScalarExecuting(It.IsAny<DbCommand>(), It.IsAny<DbCommandInterceptionContext<object>>()), Times.Never());
mockPublicInterceptor.Verify(
m => m.ScalarExecuted(It.IsAny<DbCommand>(), It.IsAny<DbCommandInterceptionContext<object>>()), Times.Never());
mockCancelable.Setup(m => m.CommandExecuting(mockCommand.Object, It.IsAny<DbInterceptionContext>())).Returns(true);
Assert.Equal(11, interceptableDbCommand.ExecuteScalar());
mockCommand.Verify(m => m.ExecuteScalar(), Times.Once());
mockCancelable.Verify(m => m.CommandExecuting(mockCommand.Object, interceptionContext), Times.Exactly(2));
mockPublicInterceptor.Verify(
m => m.ScalarExecuting(
mockCommand.Object,
It.Is<DbCommandInterceptionContext<object>>(c => c.DbContexts.Contains(context, ReferenceEquals))), Times.Once());
mockPublicInterceptor.Verify(
m => m.ScalarExecuted(
mockCommand.Object,
It.Is<DbCommandInterceptionContext<object>>(
c => c.DbContexts.Contains(context, ReferenceEquals) && (int)c.Result == 11)), Times.Once());
}
internal CommandTracer(DbContext context, Dispatchers dispatchers)
{
DebugCheck.NotNull(context);
DebugCheck.NotNull(dispatchers);
_context = context;
_dispatchers = dispatchers;
_dispatchers.AddInterceptor(this);
}
public void ExecuteScalar_should_dispatch_to_interceptor_and_optionally_execute()
{
var mockCommand = new Mock<DbCommand>();
mockCommand.Setup(m => m.ExecuteScalar()).Returns(11);
var mockCancelable = new Mock<ICancelableDbCommandInterceptor>();
var mockPublicInterceptor = new Mock<DbInterceptor> { CallBase = true };
var dispatchers = new Dispatchers();
dispatchers.AddInterceptor(mockCancelable.Object);
dispatchers.AddInterceptor(mockPublicInterceptor.Object);
var interceptionContext = new DbInterceptionContext();
var interceptableDbCommand = new InterceptableDbCommand(mockCommand.Object, interceptionContext, dispatchers);
mockCancelable.Setup(m => m.CommandExecuting(mockCommand.Object, interceptionContext)).Returns(false);
interceptableDbCommand.ExecuteScalar();
mockCommand.Verify(m => m.ExecuteScalar(), Times.Never());
mockCancelable.Verify(m => m.CommandExecuting(mockCommand.Object, interceptionContext), Times.Once());
mockPublicInterceptor.Verify(
m => m.ScalarExecuting(It.IsAny<DbCommand>(), It.IsAny<DbInterceptionContext>()), Times.Never());
mockPublicInterceptor.Verify(
m => m.ScalarExecuted(It.IsAny<DbCommand>(), It.IsAny<int>(), It.IsAny<DbInterceptionContext>()), Times.Never());
mockCancelable.Setup(m => m.CommandExecuting(mockCommand.Object, interceptionContext)).Returns(true);
Assert.Equal(11, interceptableDbCommand.ExecuteScalar());
mockCommand.Verify(m => m.ExecuteScalar(), Times.Once());
mockCancelable.Verify(m => m.CommandExecuting(mockCommand.Object, interceptionContext), Times.Exactly(2));
mockPublicInterceptor.Verify(
m => m.ScalarExecuting(mockCommand.Object, interceptionContext), Times.Once());
mockPublicInterceptor.Verify(
m => m.ScalarExecuted(mockCommand.Object, 11, interceptionContext), Times.Once());
}
public void RemoveInterceptor_removes_interceptor_for_all_interception_interfaces_implemented()
{
var mockInterceptor = new Mock<FakeInterceptor>();
var dispatchers = new Dispatchers();
dispatchers.AddInterceptor(mockInterceptor.Object);
dispatchers.RemoveInterceptor(mockInterceptor.Object);
dispatchers.Command.InternalDispatcher.Dispatch(i => ((FakeInterceptor)i).CallMe());
dispatchers.CommandTree.InternalDispatcher.Dispatch(i => ((FakeInterceptor)i).CallMe());
dispatchers.CancelableCommand.InternalDispatcher.Dispatch(i => ((FakeInterceptor)i).CallMe());
dispatchers.EntityConnection.InternalDispatcher.Dispatch(i => ((FakeInterceptor)i).CallMe());
mockInterceptor.Verify(m => m.CallMe(), Times.Never());
}
public void RemoveInterceptor_removes_interceptor_for_all_interception_interfaces_implemented()
{
var mockInterceptor = new Mock <FakeInterceptor>();
var dispatchers = new Dispatchers();
dispatchers.AddInterceptor(mockInterceptor.Object);
dispatchers.RemoveInterceptor(mockInterceptor.Object);
dispatchers.Command.InternalDispatcher.Dispatch(i => ((FakeInterceptor)i).CallMe());
dispatchers.CommandTree.InternalDispatcher.Dispatch(i => ((FakeInterceptor)i).CallMe());
dispatchers.CancelableCommand.InternalDispatcher.Dispatch(i => ((FakeInterceptor)i).CallMe());
dispatchers.EntityConnection.InternalDispatcher.Dispatch(i => ((FakeInterceptor)i).CallMe());
mockInterceptor.Verify(m => m.CallMe(), Times.Never());
}
/// <summary>
/// Registers a new <see cref="IDbInterceptor" /> to receive notifications. Note that the interceptor
/// must implement some interface that extends from <see cref="IDbInterceptor" /> to be useful.
/// </summary>
/// <param name="interceptor">The interceptor to add.</param>
public static void AddInterceptor(IDbInterceptor interceptor)
{
Check.NotNull(interceptor, "interceptor");
_dispatchers.AddInterceptor(interceptor);
}
public void ExecuteReaderAsync_should_dispatch_to_interceptor_and_optionally_execute()
{
var result = new Task<DbDataReader>(() => new Mock<DbDataReader>().Object);
var mockCommand = new Mock<DbCommand>();
mockCommand.Protected()
.Setup<Task<DbDataReader>>(
"ExecuteDbDataReaderAsync", CommandBehavior.SingleRow, ItExpr.IsAny<CancellationToken>())
.Returns(result);
var mockCancelable = new Mock<ICancelableDbCommandInterceptor>();
var mockPublicInterceptor = new Mock<DbInterceptor> { CallBase = true };
var dispatchers = new Dispatchers();
dispatchers.AddInterceptor(mockCancelable.Object);
dispatchers.AddInterceptor(mockPublicInterceptor.Object);
var interceptionContext = new DbInterceptionContext();
var interceptableDbCommand = new InterceptableDbCommand(mockCommand.Object, interceptionContext, dispatchers);
mockCancelable.Setup(m => m.CommandExecuting(mockCommand.Object, interceptionContext)).Returns(false);
Assert.NotSame(result, interceptableDbCommand.ExecuteReaderAsync(CommandBehavior.SingleRow));
mockCommand.Protected().Verify(
"ExecuteDbDataReaderAsync", Times.Never(), CommandBehavior.SingleRow, ItExpr.IsAny<CancellationToken>());
mockCancelable.Verify(m => m.CommandExecuting(mockCommand.Object, interceptionContext), Times.Once());
mockPublicInterceptor.Verify(
m => m.AsyncReaderExecuting(
It.IsAny<DbCommand>(),
It.IsAny<CommandBehavior>(),
It.IsAny<DbInterceptionContext>()), Times.Never());
mockPublicInterceptor.Verify(
m => m.AsyncReaderExecuted(
It.IsAny<DbCommand>(),
It.IsAny<CommandBehavior>(),
It.IsAny<Task<DbDataReader>>(),
It.IsAny<DbInterceptionContext>()), Times.Never());
mockCancelable.Setup(m => m.CommandExecuting(mockCommand.Object, interceptionContext)).Returns(true);
Assert.Same(result, interceptableDbCommand.ExecuteReaderAsync(CommandBehavior.SingleRow));
mockCommand.Protected().Verify(
"ExecuteDbDataReaderAsync", Times.Once(), CommandBehavior.SingleRow, ItExpr.IsAny<CancellationToken>());
mockCancelable.Verify(m => m.CommandExecuting(mockCommand.Object, interceptionContext), Times.Exactly(2));
mockPublicInterceptor.Verify(
m => m.AsyncReaderExecuting(mockCommand.Object, CommandBehavior.SingleRow, interceptionContext), Times.Once());
mockPublicInterceptor.Verify(
m => m.AsyncReaderExecuted(mockCommand.Object, CommandBehavior.SingleRow, result, interceptionContext), Times.Once());
}
public void ExecuteScalarAsync_should_dispatch_to_interceptor_and_optionally_execute()
{
var mockCommand = new Mock<DbCommand>();
var result = new Task<object>(() => 11);
mockCommand.Setup(m => m.ExecuteScalarAsync(It.IsAny<CancellationToken>())).Returns(result);
var mockCancelable = new Mock<ICancelableDbCommandInterceptor>();
var mockPublicInterceptor = new Mock<DbInterceptor> { CallBase = true };
var dispatchers = new Dispatchers();
dispatchers.AddInterceptor(mockCancelable.Object);
dispatchers.AddInterceptor(mockPublicInterceptor.Object);
var interceptionContext = new DbInterceptionContext();
var interceptableDbCommand = new InterceptableDbCommand(mockCommand.Object, interceptionContext, dispatchers);
mockCancelable.Setup(m => m.CommandExecuting(mockCommand.Object, interceptionContext)).Returns(false);
interceptableDbCommand.ExecuteScalarAsync();
mockCommand.Verify(m => m.ExecuteScalarAsync(It.IsAny<CancellationToken>()), Times.Never());
mockCancelable.Verify(m => m.CommandExecuting(mockCommand.Object, interceptionContext), Times.Once());
mockPublicInterceptor.Verify(
m => m.AsyncScalarExecuting(It.IsAny<DbCommand>(), It.IsAny<DbInterceptionContext>()), Times.Never());
mockPublicInterceptor.Verify(
m => m.AsyncScalarExecuted(It.IsAny<DbCommand>(), It.IsAny<Task<object>>(), It.IsAny<DbInterceptionContext>()),
Times.Never());
mockCancelable.Setup(m => m.CommandExecuting(mockCommand.Object, interceptionContext)).Returns(true);
Assert.Same(result, interceptableDbCommand.ExecuteScalarAsync());
mockCommand.Verify(m => m.ExecuteScalarAsync(It.IsAny<CancellationToken>()), Times.Once());
mockCancelable.Verify(m => m.CommandExecuting(mockCommand.Object, interceptionContext), Times.Exactly(2));
mockPublicInterceptor.Verify(
m => m.AsyncScalarExecuting(mockCommand.Object, interceptionContext), Times.Once());
mockPublicInterceptor.Verify(
m => m.AsyncScalarExecuted(mockCommand.Object, result, interceptionContext), Times.Once());
}
public void ExecuteNonQueryAsync_should_dispatch_to_interceptor_and_optionally_execute()
{
var mockCommand = new Mock<DbCommand>();
var result = Task.FromResult(11);
mockCommand.Setup(m => m.ExecuteNonQueryAsync(It.IsAny<CancellationToken>())).Returns(result);
var mockCancelable = new Mock<ICancelableDbCommandInterceptor>();
var mockPublicInterceptor = new Mock<DbCommandInterceptor> { CallBase = true };
var dispatchers = new Dispatchers();
dispatchers.AddInterceptor(mockCancelable.Object);
dispatchers.AddInterceptor(mockPublicInterceptor.Object);
var interceptionContext = new DbInterceptionContext();
var interceptableDbCommand = new InterceptableDbCommand(mockCommand.Object, interceptionContext, dispatchers);
mockCancelable.Setup(m => m.CommandExecuting(mockCommand.Object, It.IsAny<DbInterceptionContext>())).Returns(false);
interceptableDbCommand.ExecuteNonQueryAsync();
mockCommand.Verify(m => m.ExecuteNonQueryAsync(It.IsAny<CancellationToken>()), Times.Never());
mockCancelable.Verify(m => m.CommandExecuting(mockCommand.Object, interceptionContext), Times.Once());
mockPublicInterceptor.Verify(
m => m.NonQueryExecuting(It.IsAny<DbCommand>(), It.IsAny<DbCommandInterceptionContext<int>>()), Times.Never());
mockPublicInterceptor.Verify(
m => m.NonQueryExecuted(It.IsAny<DbCommand>(), It.IsAny<DbCommandInterceptionContext<int>>()), Times.Never());
mockCancelable.Setup(m => m.CommandExecuting(mockCommand.Object, It.IsAny<DbInterceptionContext>())).Returns(true);
var interceptResult = interceptableDbCommand.ExecuteNonQueryAsync();
interceptResult.Wait();
Assert.Equal(11, interceptResult.Result);
mockCommand.Verify(m => m.ExecuteNonQueryAsync(It.IsAny<CancellationToken>()), Times.Once());
mockCancelable.Verify(m => m.CommandExecuting(mockCommand.Object, interceptionContext), Times.Exactly(2));
mockPublicInterceptor.Verify(
m => m.NonQueryExecuting(
mockCommand.Object, It.Is<DbCommandInterceptionContext<int>>(c => c.IsAsync)), Times.Once());
mockPublicInterceptor.Verify(
m => m.NonQueryExecuted(
mockCommand.Object, It.Is<DbCommandInterceptionContext<int>>(c => c.IsAsync && c.Result == 11)), Times.Once());
}
public void ExecuteReader_should_dispatch_to_interceptor_and_optionally_execute()
{
var mockReader = new Mock<DbDataReader>();
var mockCommand = new Mock<DbCommand>();
mockCommand.Protected()
.Setup<DbDataReader>("ExecuteDbDataReader", CommandBehavior.SingleRow)
.Returns(mockReader.Object);
var mockCancelable = new Mock<ICancelableDbCommandInterceptor>();
var mockPublicInterceptor = new Mock<DbCommandInterceptor> { CallBase = true };
var dispatchers = new Dispatchers();
dispatchers.AddInterceptor(mockCancelable.Object);
dispatchers.AddInterceptor(mockPublicInterceptor.Object);
var interceptionContext = new DbInterceptionContext();
var interceptableDbCommand = new InterceptableDbCommand(mockCommand.Object, interceptionContext, dispatchers);
mockCancelable.Setup(m => m.CommandExecuting(mockCommand.Object, It.IsAny<DbInterceptionContext>())).Returns(false);
var reader = interceptableDbCommand.ExecuteReader(CommandBehavior.SingleRow);
Assert.NotSame(mockReader.Object, reader);
Assert.True(reader.NextResult());
Assert.False(reader.NextResult());
mockCommand.Protected().Verify("ExecuteDbDataReader", Times.Never(), CommandBehavior.SingleRow);
mockCancelable.Verify(m => m.CommandExecuting(mockCommand.Object, interceptionContext), Times.Once());
mockPublicInterceptor.Verify(
m => m.ReaderExecuting(
It.IsAny<DbCommand>(),
It.IsAny<DbCommandInterceptionContext<DbDataReader>>()), Times.Never());
mockPublicInterceptor.Verify(
m => m.ReaderExecuted(
It.IsAny<DbCommand>(),
It.IsAny<DbCommandInterceptionContext<DbDataReader>>()), Times.Never());
mockCancelable.Setup(m => m.CommandExecuting(mockCommand.Object, It.IsAny<DbInterceptionContext>())).Returns(true);
reader = interceptableDbCommand.ExecuteReader(CommandBehavior.SingleRow);
Assert.Same(mockReader.Object, reader);
mockCommand.Protected().Verify("ExecuteDbDataReader", Times.Once(), CommandBehavior.SingleRow);
mockCancelable.Verify(m => m.CommandExecuting(mockCommand.Object, interceptionContext), Times.Exactly(2));
mockPublicInterceptor.Verify(
m => m.ReaderExecuting(
mockCommand.Object,
It.Is<DbCommandInterceptionContext<DbDataReader>>(c => c.CommandBehavior == CommandBehavior.SingleRow)), Times.Once());
mockPublicInterceptor.Verify(
m => m.ReaderExecuted(
mockCommand.Object,
It.Is<DbCommandInterceptionContext<DbDataReader>>(
c => c.CommandBehavior == CommandBehavior.SingleRow && c.Result == mockReader.Object)), Times.Once());
}