public virtual bool Executing(DbCommand command, DbInterceptionContext interceptionContext) { DebugCheck.NotNull(command); DebugCheck.NotNull(interceptionContext); return _internalDispatcher.Dispatch(true, (b, i) => i.CommandExecuting(command, interceptionContext) && b); }
public virtual bool Opening(EntityConnection entityConnection, DbInterceptionContext interceptionContext) { DebugCheck.NotNull(entityConnection); DebugCheck.NotNull(interceptionContext); return _internalDispatcher.Dispatch(true, (b, i) => i.ConnectionOpening(entityConnection, interceptionContext) && b); }
internal override void ExecuteSql(DbTransaction transaction, MigrationStatement migrationStatement, DbInterceptionContext interceptionContext) { DebugCheck.NotNull(transaction); DebugCheck.NotNull(migrationStatement); _logger.Verbose(migrationStatement.Sql); var connection = DbInterception.Dispatch.Transaction.GetConnection(transaction, interceptionContext); var providerServices = DbProviderServices.GetProviderServices(connection); if (providerServices != null) { providerServices.RegisterInfoMessageHandler( connection, message => { if (!string.Equals(message, _lastInfoMessage, StringComparison.OrdinalIgnoreCase)) { _logger.Warning(message); // simple duplicate filtering _lastInfoMessage = message; } }); } base.ExecuteSql(transaction, migrationStatement, interceptionContext); }
/// <summary> /// Creates a new <see cref="DbInterceptionContext" /> by copying state from the given /// interception context. See <see cref="DbInterceptionContext.Clone" /> /// </summary> /// <param name="copyFrom">The context from which to copy state.</param> protected DbInterceptionContext(DbInterceptionContext copyFrom) { Check.NotNull(copyFrom, "copyFrom"); _dbContexts = copyFrom.DbContexts.Where(c => c.InternalContext == null || !c.InternalContext.IsDisposed).ToList(); _objectContexts = copyFrom.ObjectContexts.Where(c => !c.IsDisposed).ToList(); _isAsync = copyFrom._isAsync; }
public void New_interception_context_has_no_state() { var interceptionContext = new DbInterceptionContext(); Assert.Empty(interceptionContext.ObjectContexts); Assert.Empty(interceptionContext.DbContexts); Assert.False(interceptionContext.IsAsync); }
public virtual void Loaded(DbConfigurationLoadedEventArgs loadedEventArgs, DbInterceptionContext interceptionContext) { DebugCheck.NotNull(loadedEventArgs); DebugCheck.NotNull(interceptionContext); var clonedInterceptionContext = new DbConfigurationInterceptionContext(interceptionContext); _internalDispatcher.Dispatch(i => i.Loaded(loadedEventArgs, clonedInterceptionContext)); }
public virtual DbCommandTree Created(DbCommandTree commandTree, DbInterceptionContext interceptionContext) { DebugCheck.NotNull(commandTree); DebugCheck.NotNull(interceptionContext); return _internalDispatcher.Dispatch( commandTree, new DbCommandTreeInterceptionContext(interceptionContext), (i, c) => i.TreeCreated(c)); }
/// <summary> /// Creates a new <see cref="EnlistTransactionInterceptionContext" /> by copying immutable state from the given /// interception context. Also see <see cref="Clone" /> /// </summary> /// <param name="copyFrom">The context from which to copy state.</param> public EnlistTransactionInterceptionContext(DbInterceptionContext copyFrom) : base(copyFrom) { Check.NotNull(copyFrom, "copyFrom"); var asThisType = copyFrom as EnlistTransactionInterceptionContext; if (asThisType != null) { _transaction = asThisType._transaction; } }
/// <summary> /// Creates a new <see cref="DbTransactionInterceptionContext" /> by copying immutable state from the given /// interception context. Also see <see cref="Clone" /> /// </summary> /// <param name="copyFrom">The context from which to copy state.</param> public DbTransactionInterceptionContext(DbInterceptionContext copyFrom) : base(copyFrom) { var transactionInterceptionContext = copyFrom as DbTransactionInterceptionContext; if (transactionInterceptionContext != null) { _connection = transactionInterceptionContext.Connection; } Check.NotNull(copyFrom, "copyFrom"); }
/// <summary> /// Creates a new <see cref="DbCommandInterceptionContext" /> by copying state from the given /// interception context. Also see <see cref="Clone" /> /// </summary> /// <param name="copyFrom">The context from which to copy state.</param> public DbCommandInterceptionContext(DbInterceptionContext copyFrom) : base(copyFrom) { Check.NotNull(copyFrom, "copyFrom"); var asThisType = copyFrom as DbCommandInterceptionContext; if (asThisType != null) { _commandBehavior = asThisType._commandBehavior; } }
/// <summary> /// Sends <see cref="IDbTransactionInterceptor.IsolationLevelGetting" /> and /// <see cref="IDbTransactionInterceptor.IsolationLevelGot" /> to any <see cref="IDbTransactionInterceptor" /> /// registered on <see cref="DbInterception" /> before/after /// getting <see cref="DbTransaction.IsolationLevel" />. /// </summary> /// <remarks> /// Note that the value of the property 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="transaction">The transaction 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 IsolationLevel GetIsolationLevel(DbTransaction transaction, DbInterceptionContext interceptionContext) { Check.NotNull(transaction, "transaction"); Check.NotNull(interceptionContext, "interceptionContext"); return InternalDispatcher.Dispatch( transaction, (t, c) => t.IsolationLevel, new DbTransactionInterceptionContext<IsolationLevel>(interceptionContext), (i, t, c) => i.IsolationLevelGetting(t, c), (i, t, c) => i.IsolationLevelGot(t, c)); }
/// <summary> /// Sends <see cref="IDbTransactionInterceptor.ConnectionGetting" /> and /// <see cref="IDbTransactionInterceptor.ConnectionGot" /> to any <see cref="IDbTransactionInterceptor" /> /// registered on <see cref="DbInterception" /> before/after /// getting <see cref="DbTransaction.Connection" />. /// </summary> /// <remarks> /// Note that the value of the property 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="transaction">The transaction 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 DbConnection GetConnection(DbTransaction transaction, DbInterceptionContext interceptionContext) { Check.NotNull(transaction, "transaction"); Check.NotNull(interceptionContext, "interceptionContext"); return InternalDispatcher.Dispatch( transaction, (t, c) => t.Connection, new DbTransactionInterceptionContext<DbConnection>(interceptionContext), (i, t, c) => i.ConnectionGetting(t, c), (i, t, c) => i.ConnectionGot(t, c)); }
public InterceptableDbCommand(DbCommand command, DbInterceptionContext context, DbDispatchers dispatchers = null) { DebugCheck.NotNull(command); DebugCheck.NotNull(context); GC.SuppressFinalize(this); _command = command; _interceptionContext = context; _dispatchers = dispatchers ?? DbInterception.Dispatch; }
/// <summary> /// Sends <see cref="IDbConnectionInterceptor.Closing" /> and /// <see cref="IDbConnectionInterceptor.Closed" /> to any <see cref="IDbConnectionInterceptor" /> /// registered on <see cref="DbInterception" /> before/after making a /// call to <see cref="DbConnection.Close" />. /// </summary> /// <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> public virtual void Close( DbConnection connection, DbInterceptionContext interceptionContext) { Check.NotNull(connection, "connection"); Check.NotNull(interceptionContext, "interceptionContext"); InternalDispatcher.Dispatch( connection, (t, c) => t.Close(), new DbConnectionInterceptionContext(interceptionContext), (i, t, c) => i.Closing(t, c), (i, t, c) => i.Closed(t, c)); }
public void Interception_context_can_be_made_async_and_other_state_is_preserved() { var objectContext = new ObjectContext(); var dbContext = CreateDbContext(objectContext); var interceptionContext = new DbInterceptionContext() .WithDbContext(dbContext) .WithObjectContext(objectContext) .AsAsync(); Assert.Equal(new[] { objectContext }, interceptionContext.ObjectContexts); Assert.Equal(new[] { dbContext }, interceptionContext.DbContexts); Assert.True(interceptionContext.IsAsync); }
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 DbDispatchers(); 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()); }
public void Dispose_executes_operation_and_dispatches_to_interceptors() { var transactionMock = new Mock<DbTransaction>(); var interceptorMock = new Mock<IDbTransactionInterceptor>(); var dispatcher = new DbTransactionDispatcher(); var internalDispatcher = dispatcher.InternalDispatcher; internalDispatcher.Add(interceptorMock.Object); var interceptionContext = new DbInterceptionContext(); dispatcher.Dispose(transactionMock.Object, interceptionContext); transactionMock.Protected().Verify("Dispose", Times.Once(), ItExpr.IsAny<bool>()); interceptorMock.Verify(m => m.Disposing(transactionMock.Object, It.IsAny<DbTransactionInterceptionContext>()), Times.Once()); interceptorMock.Verify(m => m.Disposed(transactionMock.Object, It.IsAny<DbTransactionInterceptionContext>()), Times.Once()); }
public void Opening_dispatches_to_interceptors() { var interceptionContext = new DbInterceptionContext(); var connection = new Mock<EntityConnection>().Object; var mockInterceptor = new Mock<ICancelableEntityConnectionInterceptor>(); mockInterceptor.Setup(m => m.ConnectionOpening(connection, interceptionContext)).Returns(true); var dispatcher = new CancelableEntityConnectionDispatcher(); var internalDispatcher = dispatcher.InternalDispatcher; internalDispatcher.Add(mockInterceptor.Object); Assert.True(dispatcher.Opening(connection, interceptionContext)); mockInterceptor.Verify(m => m.ConnectionOpening(connection, interceptionContext)); }
public void Interception_context_can_be_associated_with_one_or_more_DbContexts() { var context1 = CreateDbContext(new ObjectContext()); var interceptionContext1 = new DbInterceptionContext().WithDbContext(context1); Assert.Equal(new[] { context1 }, interceptionContext1.DbContexts); var context2 = CreateDbContext(new ObjectContext()); var interceptionContext2 = interceptionContext1.WithDbContext(context2); Assert.Contains(context1, interceptionContext2.DbContexts); Assert.Contains(context2, interceptionContext2.DbContexts); Assert.Empty(interceptionContext2.ObjectContexts); Assert.Equal(new[] { context1 }, interceptionContext1.DbContexts); }
public void Commit_executes_operation_and_dispatches_to_interceptors() { var transactionMock = new Mock<DbTransaction>(); transactionMock.Protected().Setup<DbConnection>("DbConnection").Returns(new Mock<DbConnection>().Object); var interceptorMock = new Mock<IDbTransactionInterceptor>(); var dispatcher = new DbTransactionDispatcher(); var internalDispatcher = dispatcher.InternalDispatcher; internalDispatcher.Add(interceptorMock.Object); var interceptionContext = new DbInterceptionContext(); dispatcher.Commit(transactionMock.Object, interceptionContext); transactionMock.Verify(m => m.Commit(), Times.Once()); interceptorMock.Verify(m => m.Committing(transactionMock.Object, It.IsAny<DbTransactionInterceptionContext>()), Times.Once()); interceptorMock.Verify(m => m.Committed(transactionMock.Object, It.IsAny<DbTransactionInterceptionContext>()), Times.Once()); }
public void Executing_dispatches_to_interceptors() { var interceptionContext = new DbInterceptionContext(); var command = new Mock<DbCommand>().Object; var mockInterceptor = new Mock<ICancelableDbCommandInterceptor>(); mockInterceptor.Setup(m => m.CommandExecuting(command, interceptionContext)).Returns(true); var dispatcher = new CancelableDbCommandDispatcher(); var internalDispatcher = dispatcher.InternalDispatcher; internalDispatcher.Add(mockInterceptor.Object); Assert.True(dispatcher.Executing(command, interceptionContext)); mockInterceptor.Verify(m => m.CommandExecuting(command, interceptionContext)); }
public void Interception_context_can_be_associated_with_one_or_more_DbContexts() { var context1 = CreateDbContext(new ObjectContext()); var interceptionContext1 = new DbInterceptionContext().WithDbContext(context1); Assert.Equal(new[] { context1 }, interceptionContext1.DbContexts); var context2 = CreateDbContext(new ObjectContext()); var interceptionContext2 = interceptionContext1.WithDbContext(context2); Assert.Contains(context1, interceptionContext2.DbContexts); Assert.Contains(context2, interceptionContext2.DbContexts); Assert.Empty(interceptionContext2.ObjectContexts); Assert.Equal(new[] { context1 }, interceptionContext1.DbContexts); }
public void Dispose_executes_operation_and_dispatches_to_interceptors() { var transactionMock = new Mock <DbTransaction>(); var interceptorMock = new Mock <IDbTransactionInterceptor>(); var dispatcher = new DbTransactionDispatcher(); var internalDispatcher = dispatcher.InternalDispatcher; internalDispatcher.Add(interceptorMock.Object); var interceptionContext = new DbInterceptionContext(); dispatcher.Dispose(transactionMock.Object, interceptionContext); transactionMock.Protected().Verify("Dispose", Times.Once(), ItExpr.IsAny <bool>()); interceptorMock.Verify(m => m.Disposing(transactionMock.Object, It.IsAny <DbTransactionInterceptionContext>()), Times.Once()); interceptorMock.Verify(m => m.Disposed(transactionMock.Object, It.IsAny <DbTransactionInterceptionContext>()), Times.Once()); }
public void Loaded_dispatches_to_interceptors() { var interceptionContext = new DbInterceptionContext(); var eventArgs = new DbConfigurationLoadedEventArgs(new Mock<InternalConfiguration>(null, null, null, null, null).Object); var mockInterceptor1 = new Mock<IDbConfigurationInterceptor>(); var mockInterceptor2 = new Mock<IDbConfigurationInterceptor>(); var dispatcher = new DbConfigurationDispatcher(); var internalDispatcher = dispatcher.InternalDispatcher; internalDispatcher.Add(mockInterceptor1.Object); internalDispatcher.Add(mockInterceptor2.Object); dispatcher.Loaded(eventArgs, interceptionContext); mockInterceptor1.Verify(m => m.Loaded(eventArgs, It.IsAny<DbConfigurationInterceptionContext>()), Times.Once()); mockInterceptor2.Verify(m => m.Loaded(eventArgs, It.IsAny<DbConfigurationInterceptionContext>()), Times.Once()); }
public void GetState_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 DbInterceptionContext(); dispatcher.GetState(mockConnection.Object, interceptionContext); mockConnection.Verify(m => m.State, Times.Once()); mockInterceptor.Verify(m => m.StateGetting(mockConnection.Object, It.IsAny <DbConnectionInterceptionContext <ConnectionState> >()), Times.Once()); mockInterceptor.Verify(m => m.StateGot(mockConnection.Object, It.IsAny <DbConnectionInterceptionContext <ConnectionState> >()), Times.Once()); }
public void GetConnection_executes_operation_and_dispatches_to_interceptors() { var transactionMock = new Mock<DbTransaction>(); var interceptorMock = new Mock<IDbTransactionInterceptor>(); var dispatcher = new DbTransactionDispatcher(); var internalDispatcher = dispatcher.InternalDispatcher; internalDispatcher.Add(interceptorMock.Object); var interceptionContext = new DbInterceptionContext(); dispatcher.GetConnection(transactionMock.Object, interceptionContext); transactionMock.Protected().Verify<DbConnection>("DbConnection", Times.Once()); interceptorMock.Verify( m => m.ConnectionGetting(transactionMock.Object, It.IsAny<DbTransactionInterceptionContext<DbConnection>>()), Times.Once()); interceptorMock.Verify( m => m.ConnectionGot(transactionMock.Object, It.IsAny<DbTransactionInterceptionContext<DbConnection>>()), Times.Once()); }
internal EntityCommand(DbInterceptionContext interceptionContext, EntityDataReaderFactory factory) { DebugCheck.NotNull(interceptionContext); // Initalize the member field with proper default values _designTimeVisible = true; _commandType = CommandType.Text; _updatedRowSource = UpdateRowSource.Both; _parameters = new EntityParameterCollection(); _interceptionContext = interceptionContext; // Future Enhancement: (See SQLPT #300004256) At some point it would be // really nice to read defaults from a global configuration, but we're not // doing that today. _enableQueryPlanCaching = true; _entityDataReaderFactory = factory ?? new EntityDataReaderFactory(); }
public void GetIsolationLevel_executes_operation_and_dispatches_to_interceptors() { var transactionMock = new Mock<DbTransaction>(); var interceptorMock = new Mock<IDbTransactionInterceptor>(); var dispatcher = new DbTransactionDispatcher(); var internalDispatcher = dispatcher.InternalDispatcher; internalDispatcher.Add(interceptorMock.Object); var interceptionContext = new DbInterceptionContext(); dispatcher.GetIsolationLevel(transactionMock.Object, interceptionContext); transactionMock.Verify(m => m.IsolationLevel, Times.Once()); interceptorMock.Verify( m => m.IsolationLevelGetting(transactionMock.Object, It.IsAny<DbTransactionInterceptionContext<IsolationLevel>>()), Times.Once()); interceptorMock.Verify( m => m.IsolationLevelGot(transactionMock.Object, It.IsAny<DbTransactionInterceptionContext<IsolationLevel>>()), Times.Once()); }
public void Executing_dispatches_to_interceptors() { var interceptionContext = new DbInterceptionContext(); var command = new Mock <DbCommand>().Object; var mockInterceptor = new Mock <ICancelableDbCommandInterceptor>(); mockInterceptor.Setup(m => m.CommandExecuting(command, interceptionContext)).Returns(true); var dispatcher = new CancelableDbCommandDispatcher(); var internalDispatcher = dispatcher.InternalDispatcher; internalDispatcher.Add(mockInterceptor.Object); Assert.True(dispatcher.Executing(command, interceptionContext)); mockInterceptor.Verify(m => m.CommandExecuting(command, interceptionContext)); }
public void Loaded_dispatches_to_interceptors() { var interceptionContext = new DbInterceptionContext(); var eventArgs = new DbConfigurationLoadedEventArgs(new Mock <InternalConfiguration>(null, null, null, null, null).Object); var mockInterceptor1 = new Mock <IDbConfigurationInterceptor>(); var mockInterceptor2 = new Mock <IDbConfigurationInterceptor>(); var dispatcher = new DbConfigurationDispatcher(); var internalDispatcher = dispatcher.InternalDispatcher; internalDispatcher.Add(mockInterceptor1.Object); internalDispatcher.Add(mockInterceptor2.Object); dispatcher.Loaded(eventArgs, interceptionContext); mockInterceptor1.Verify(m => m.Loaded(eventArgs, It.IsAny <DbConfigurationInterceptionContext>()), Times.Once()); mockInterceptor2.Verify(m => m.Loaded(eventArgs, It.IsAny <DbConfigurationInterceptionContext>()), Times.Once()); }
public void Opening_dispatches_to_interceptors() { var interceptionContext = new DbInterceptionContext(); var connection = new Mock <EntityConnection>().Object; var mockInterceptor = new Mock <ICancelableEntityConnectionInterceptor>(); mockInterceptor.Setup(m => m.ConnectionOpening(connection, interceptionContext)).Returns(true); var dispatcher = new CancelableEntityConnectionDispatcher(); var internalDispatcher = dispatcher.InternalDispatcher; internalDispatcher.Add(mockInterceptor.Object); Assert.True(dispatcher.Opening(connection, interceptionContext)); mockInterceptor.Verify(m => m.ConnectionOpening(connection, interceptionContext)); }
/// <summary> /// Sends <see cref="IDbConnectionInterceptor.Disposing" /> and /// <see cref="IDbConnectionInterceptor.Disposed" /> to any <see cref="IDbConnectionInterceptor" /> /// registered on <see cref="DbInterception" /> before/after making a /// call to <see cref="Component.Dispose()" />. /// </summary> /// <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> public virtual void Dispose( DbConnection connection, DbInterceptionContext interceptionContext) { Check.NotNull(connection, "connection"); Check.NotNull(interceptionContext, "interceptionContext"); InternalDispatcher.Dispatch( connection, (t, c) => { // Will invoke the explicit IDisposable implementation if one exists using (t) { } }, new DbConnectionInterceptionContext(interceptionContext), (i, t, c) => i.Disposing(t, c), (i, t, c) => i.Disposed(t, c)); }
/// <summary> /// Sends <see cref="IDbConnectionInterceptor.Opening" /> and /// <see cref="IDbConnectionInterceptor.Opened" /> to any <see cref="IDbConnectionInterceptor" /> /// registered on <see cref="DbInterception" /> before/after making a /// call to <see cref="DbConnection.Open" />. /// </summary> /// <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> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>A task that represents the asynchronous operation.</returns> public virtual Task OpenAsync( DbConnection dbConnection, DbInterceptionContext interceptionContext, CancellationToken cancellationToken) { Check.NotNull(dbConnection, "dbConnection"); Check.NotNull(interceptionContext, "interceptionContext"); var clonedInterceptionContext = new DbConnectionInterceptionContext(interceptionContext); if (!clonedInterceptionContext.IsAsync) { clonedInterceptionContext = clonedInterceptionContext.AsAsync(); } return(InternalDispatcher.DispatchAsync( () => dbConnection.OpenAsync(cancellationToken), clonedInterceptionContext, i => i.Opening(dbConnection, clonedInterceptionContext), i => i.Opened(dbConnection, clonedInterceptionContext))); }
/// <summary> /// Sends <see cref="IDbTransactionInterceptor.Disposing" /> and /// <see cref="IDbTransactionInterceptor.Disposed" /> to any <see cref="IDbConnectionInterceptor" /> /// registered on <see cref="DbInterception" /> before/after making a /// call to <see cref="DbTransaction.Dispose()" />. /// </summary> /// <param name="transaction">The transaction on which the operation will be executed.</param> /// <param name="interceptionContext">Optional information about the context of the call being made.</param> public virtual void Dispose(DbTransaction transaction, DbInterceptionContext interceptionContext) { Check.NotNull(transaction, "transaction"); Check.NotNull(interceptionContext, "interceptionContext"); var clonedInterceptionContext = new DbTransactionInterceptionContext(interceptionContext); if (transaction.Connection != null) { clonedInterceptionContext = clonedInterceptionContext.WithConnection(transaction.Connection); } InternalDispatcher.Dispatch( transaction, (t, c) => t.Dispose(), clonedInterceptionContext, (i, t, c) => i.Disposing(t, c), (i, t, c) => i.Disposed(t, c)); }
public void GetConnection_executes_operation_and_dispatches_to_interceptors() { var transactionMock = new Mock <DbTransaction>(); var interceptorMock = new Mock <IDbTransactionInterceptor>(); var dispatcher = new DbTransactionDispatcher(); var internalDispatcher = dispatcher.InternalDispatcher; internalDispatcher.Add(interceptorMock.Object); var interceptionContext = new DbInterceptionContext(); dispatcher.GetConnection(transactionMock.Object, interceptionContext); transactionMock.Protected().Verify <DbConnection>("DbConnection", Times.Once()); interceptorMock.Verify( m => m.ConnectionGetting(transactionMock.Object, It.IsAny <DbTransactionInterceptionContext <DbConnection> >()), Times.Once()); interceptorMock.Verify( m => m.ConnectionGot(transactionMock.Object, It.IsAny <DbTransactionInterceptionContext <DbConnection> >()), Times.Once()); }
public void Rollback_executes_operation_and_dispatches_to_interceptors() { var transactionMock = new Mock <DbTransaction>(); transactionMock.Protected().Setup <DbConnection>("DbConnection").Returns(new Mock <DbConnection>().Object); var interceptorMock = new Mock <IDbTransactionInterceptor>(); var dispatcher = new DbTransactionDispatcher(); var internalDispatcher = dispatcher.InternalDispatcher; internalDispatcher.Add(interceptorMock.Object); var interceptionContext = new DbInterceptionContext(); dispatcher.Rollback(transactionMock.Object, interceptionContext); transactionMock.Verify(m => m.Rollback(), Times.Once()); interceptorMock.Verify(m => m.RollingBack(transactionMock.Object, It.IsAny <DbTransactionInterceptionContext>()), Times.Once()); interceptorMock.Verify(m => m.RolledBack(transactionMock.Object, It.IsAny <DbTransactionInterceptionContext>()), Times.Once()); }
public void GetIsolationLevel_executes_operation_and_dispatches_to_interceptors() { var transactionMock = new Mock <DbTransaction>(); var interceptorMock = new Mock <IDbTransactionInterceptor>(); var dispatcher = new DbTransactionDispatcher(); var internalDispatcher = dispatcher.InternalDispatcher; internalDispatcher.Add(interceptorMock.Object); var interceptionContext = new DbInterceptionContext(); dispatcher.GetIsolationLevel(transactionMock.Object, interceptionContext); transactionMock.Verify(m => m.IsolationLevel, Times.Once()); interceptorMock.Verify( m => m.IsolationLevelGetting(transactionMock.Object, It.IsAny <DbTransactionInterceptionContext <IsolationLevel> >()), Times.Once()); interceptorMock.Verify( m => m.IsolationLevelGot(transactionMock.Object, It.IsAny <DbTransactionInterceptionContext <IsolationLevel> >()), Times.Once()); }
public void Created_dispatches_to_interceptors_which_can_modify_result() { var interceptionContext = new DbInterceptionContext(); var tree = new Mock<DbCommandTree>().Object; var mockInterceptor = new Mock<IDbCommandTreeInterceptor>(); var interceptedTree = new Mock<DbCommandTree>().Object; mockInterceptor.Setup(m => m.TreeCreated(It.IsAny<DbCommandTreeInterceptionContext>())) .Callback<DbCommandTreeInterceptionContext>( i => { Assert.Same(tree, i.Result); Assert.Same(tree, i.OriginalResult); i.Result = interceptedTree; }); var dispatcher = new DbCommandTreeDispatcher(); var internalDispatcher = dispatcher.InternalDispatcher; internalDispatcher.Add(mockInterceptor.Object); Assert.Same(interceptedTree, dispatcher.Created(tree, interceptionContext)); mockInterceptor.Verify(m => m.TreeCreated(It.IsAny<DbCommandTreeInterceptionContext>())); }
/// <summary> /// Creates a new <see cref="DbConnectionPropertyInterceptionContext{TValue}" /> by copying immutable state from the given /// interception context. Also see <see cref="Clone" /> /// </summary> /// <param name="copyFrom">The context from which to copy state.</param> public DbConnectionPropertyInterceptionContext(DbInterceptionContext copyFrom) : base(copyFrom) { Check.NotNull(copyFrom, "copyFrom"); }
/// <summary> /// Creates a new <see cref="DbConfigurationInterceptionContext" /> by copying state from the given /// interception context. Also see <see cref="DbConfigurationInterceptionContext.Clone" /> /// </summary> /// <param name="copyFrom">The context from which to copy state.</param> public DbConfigurationInterceptionContext(DbInterceptionContext copyFrom) : base(copyFrom) { Check.NotNull(copyFrom, "copyFrom"); }
public void ExecuteReaderAsync_should_dispatch_to_interceptor_and_optionally_execute() { var result = Task.FromResult(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<DbCommandInterceptor> { CallBase = true }; var dispatchers = new DbDispatchers(); 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); 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.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); var interceptResult = interceptableDbCommand.ExecuteReaderAsync(CommandBehavior.SingleRow); interceptResult.Wait(); Assert.Same(result.Result, interceptResult.Result); 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.ReaderExecuting( mockCommand.Object, It.Is<DbCommandInterceptionContext<DbDataReader>>(c => c.IsAsync && c.CommandBehavior == CommandBehavior.SingleRow)), Times.Once()); mockPublicInterceptor.Verify( m => m.ReaderExecuted( mockCommand.Object, It.Is<DbCommandInterceptionContext<DbDataReader>>( c => c.IsAsync && c.CommandBehavior == CommandBehavior.SingleRow && c.Result == result.Result)), Times.Once()); }
public abstract bool ConnectionOpening(EntityConnection connection, DbInterceptionContext interceptionContext);
/// <summary> /// Creates a new <see cref="MutableInterceptionContext{TResult}" /> by copying immutable state from the given /// interception context. Also see <see cref="DbInterceptionContext.Clone" /> /// </summary> /// <param name="copyFrom">The context from which to copy state.</param> protected MutableInterceptionContext(DbInterceptionContext copyFrom) : base(copyFrom) { Check.NotNull(copyFrom, "copyFrom"); }
public void ExecuteScalarAsync_should_dispatch_to_interceptor_and_optionally_execute() { var mockCommand = new Mock<DbCommand>(); var result = Task.FromResult<object>(11); mockCommand.Setup(m => m.ExecuteScalarAsync(It.IsAny<CancellationToken>())).Returns(result); var mockCancelable = new Mock<ICancelableDbCommandInterceptor>(); var mockPublicInterceptor = new Mock<DbCommandInterceptor> { CallBase = true }; var dispatchers = new DbDispatchers(); 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.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.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); var interceptResult = interceptableDbCommand.ExecuteScalarAsync(); interceptResult.Wait(); Assert.Equal(11, interceptResult.Result); 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.ScalarExecuting(mockCommand.Object, It.Is<DbCommandInterceptionContext<object>>(c => c.IsAsync)), Times.Once()); mockPublicInterceptor.Verify( m => m.ScalarExecuted( mockCommand.Object, It.Is<DbCommandInterceptionContext<object>>(c => c.IsAsync && (int)c.Result == 11)), Times.Once()); }
public abstract bool CommandExecuting(DbCommand command, DbInterceptionContext interceptionContext);
public void GetState_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 DbInterceptionContext(); dispatcher.GetState(mockConnection.Object, interceptionContext); mockConnection.Verify(m => m.State, Times.Once()); mockInterceptor.Verify(m => m.StateGetting(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext<ConnectionState>>()), Times.Once()); mockInterceptor.Verify(m => m.StateGot(mockConnection.Object, It.IsAny<DbConnectionInterceptionContext<ConnectionState>>()), Times.Once()); }
/// <summary> /// Creates a new <see cref="DbCommandInterceptionContext{TResult}" /> by copying immutable state from the given /// interception context. Also see <see cref="Clone" /> /// </summary> /// <param name="copyFrom">The context from which to copy state.</param> public DbCommandInterceptionContext(DbInterceptionContext copyFrom) : base(copyFrom) { }
/// <summary> /// Creates a new <see cref="DbTransactionInterceptionContext{TResult}" /> by copying immutable state from the given /// interception context. Also see <see cref="Clone" /> /// </summary> /// <param name="copyFrom">The context from which to copy state.</param> public DbTransactionInterceptionContext(DbInterceptionContext copyFrom) : base(copyFrom) { Check.NotNull(copyFrom, "copyFrom"); }
/// <summary> /// Sends <see cref="IDbConnectionInterceptor.Disposing" /> and /// <see cref="IDbConnectionInterceptor.Disposed" /> to any <see cref="IDbConnectionInterceptor" /> /// registered on <see cref="DbInterception" /> before/after making a /// call to <see cref="Component.Dispose()" />. /// </summary> /// <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> public virtual void Dispose( DbConnection connection, DbInterceptionContext interceptionContext) { Check.NotNull(connection, "connection"); Check.NotNull(interceptionContext, "interceptionContext"); InternalDispatcher.Dispatch( connection, (t, c) => { // Will invoke the explicit IDisposable implementation if one exists using (t) { } }, new DbConnectionInterceptionContext(interceptionContext), (i, t, c) => i.Disposing(t, c), (i, t, c) => i.Disposed(t, c)); }
/// <summary> /// Creates a new <see cref="T:System.Data.Entity.Infrastructure.Interception.DbConnectionInterceptionContext`1" /> by copying immutable state from the given /// interception context. Also see <see cref="M:System.Data.Entity.Infrastructure.Interception.DbConnectionInterceptionContext`1.Clone" /> /// </summary> /// <param name="copyFrom">The context from which to copy state.</param> public DbConnectionInterceptionContext(DbInterceptionContext copyFrom) : base(copyFrom) { Check.NotNull <DbInterceptionContext>(copyFrom, nameof(copyFrom)); }
/// <summary> /// Creates a new <see cref="T:System.Data.Entity.Infrastructure.Interception.MutableInterceptionContext" /> by copying immutable state from the given /// interception context. Also see <see cref="M:System.Data.Entity.Infrastructure.Interception.DbInterceptionContext.Clone" /> /// </summary> /// <param name="copyFrom">The context from which to copy state.</param> protected MutableInterceptionContext(DbInterceptionContext copyFrom) : base(copyFrom) { Check.NotNull <DbInterceptionContext>(copyFrom, nameof(copyFrom)); }
/// <summary> /// Creates a new <see cref="DbCommandTreeInterceptionContext" /> by copying state from the given /// interception context. Also see <see cref="DbCommandTreeInterceptionContext.Clone" /> /// </summary> /// <param name="copyFrom">The context from which to copy state.</param> public DbCommandTreeInterceptionContext(DbInterceptionContext copyFrom) : base(copyFrom) { Check.NotNull(copyFrom, "copyFrom"); }
/// <summary> /// Sends <see cref="M:System.Data.Entity.Infrastructure.Interception.IDbTransactionInterceptor.Committing(System.Data.Common.DbTransaction,System.Data.Entity.Infrastructure.Interception.DbTransactionInterceptionContext)" /> and /// <see cref="M:System.Data.Entity.Infrastructure.Interception.IDbTransactionInterceptor.Committed(System.Data.Common.DbTransaction,System.Data.Entity.Infrastructure.Interception.DbTransactionInterceptionContext)" /> 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.DbTransaction.Commit" />. /// </summary> /// <param name="transaction">The transaction on which the operation will be executed.</param> /// <param name="interceptionContext">Optional information about the context of the call being made.</param> public virtual void Commit(DbTransaction transaction, DbInterceptionContext interceptionContext) { Check.NotNull <DbTransaction>(transaction, nameof(transaction)); Check.NotNull <DbInterceptionContext>(interceptionContext, nameof(interceptionContext)); this.InternalDispatcher.Dispatch <DbTransaction, DbTransactionInterceptionContext>(transaction, (Action <DbTransaction, DbTransactionInterceptionContext>)((t, c) => t.Commit()), new DbTransactionInterceptionContext(interceptionContext).WithConnection(transaction.Connection), (Action <IDbTransactionInterceptor, DbTransaction, DbTransactionInterceptionContext>)((i, t, c) => i.Committing(t, c)), (Action <IDbTransactionInterceptor, DbTransaction, DbTransactionInterceptionContext>)((i, t, c) => i.Committed(t, c))); }
/// <summary> /// Sends <see cref="M:System.Data.Entity.Infrastructure.Interception.IDbConnectionInterceptor.Closing(System.Data.Common.DbConnection,System.Data.Entity.Infrastructure.Interception.DbConnectionInterceptionContext)" /> and /// <see cref="M:System.Data.Entity.Infrastructure.Interception.IDbConnectionInterceptor.Closed(System.Data.Common.DbConnection,System.Data.Entity.Infrastructure.Interception.DbConnectionInterceptionContext)" /> 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.Close" />. /// </summary> /// <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> public virtual void Close(DbConnection connection, DbInterceptionContext interceptionContext) { Check.NotNull <DbConnection>(connection, nameof(connection)); Check.NotNull <DbInterceptionContext>(interceptionContext, nameof(interceptionContext)); this.InternalDispatcher.Dispatch <DbConnection, DbConnectionInterceptionContext>(connection, (Action <DbConnection, DbConnectionInterceptionContext>)((t, c) => t.Close()), new DbConnectionInterceptionContext(interceptionContext), (Action <IDbConnectionInterceptor, DbConnection, DbConnectionInterceptionContext>)((i, t, c) => i.Closing(t, c)), (Action <IDbConnectionInterceptor, DbConnection, DbConnectionInterceptionContext>)((i, t, c) => i.Closed(t, c))); }
public virtual DbCommandTree Created( DbCommandTree commandTree, DbInterceptionContext interceptionContext) { return(this._internalDispatcher.Dispatch <DbCommandTreeInterceptionContext, DbCommandTree>(commandTree, new DbCommandTreeInterceptionContext(interceptionContext), (Action <IDbCommandTreeInterceptor, DbCommandTreeInterceptionContext>)((i, c) => i.TreeCreated(c)))); }