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()); }