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());
}
public bool AnyModelTableExistsInDatabase(
ObjectContext context, DbConnection connection, List <EntitySet> modelTables, string edmMetadataContextTableName)
{
var modelTablesListBuilder = new StringBuilder();
foreach (var modelTable in modelTables)
{
modelTablesListBuilder.Append("'");
modelTablesListBuilder.Append((string)modelTable.MetadataProperties["Schema"].Value);
modelTablesListBuilder.Append(".");
modelTablesListBuilder.Append(GetTableName(modelTable));
modelTablesListBuilder.Append("',");
}
modelTablesListBuilder.Remove(modelTablesListBuilder.Length - 1, 1);
var dbCommand = connection.CreateCommand();
using (var command = new InterceptableDbCommand(dbCommand, context.InterceptionContext))
{
command.CommandText = @"
SELECT Count(*)
FROM INFORMATION_SCHEMA.TABLES AS t
WHERE t.TABLE_SCHEMA + '.' + t.TABLE_NAME IN (" + modelTablesListBuilder + @")
OR t.TABLE_NAME = '" + edmMetadataContextTableName + "'";
var executionStrategy = DbProviderServices.GetExecutionStrategy(connection);
try
{
return(executionStrategy.Execute(
() =>
{
if (DbInterception.Dispatch.Connection.GetState(connection, context.InterceptionContext) == ConnectionState.Broken)
{
DbInterception.Dispatch.Connection.Close(connection, context.InterceptionContext);
}
if (DbInterception.Dispatch.Connection.GetState(connection, context.InterceptionContext) == ConnectionState.Closed)
{
DbInterception.Dispatch.Connection.Open(connection, context.InterceptionContext);
}
return (int)command.ExecuteScalar() > 0;
}));
}
finally
{
if (DbInterception.Dispatch.Connection.GetState(connection, context.InterceptionContext) != ConnectionState.Closed)
{
DbInterception.Dispatch.Connection.Close(connection, context.InterceptionContext);
}
}
}
}
protected FunctionUpdateCommand(
UpdateTranslator translator,
ReadOnlyCollection<IEntityStateEntry> stateEntries,
ExtractedStateEntry stateEntry,
DbCommand dbCommand)
: base(translator, stateEntry.Original, stateEntry.Current)
{
// populate the main state entry for error reporting
_stateEntries = stateEntries;
_dbCommand = new InterceptableDbCommand(dbCommand, translator.InterceptionContext);
}
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 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.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 bool AnyModelTableExistsInDatabase(
ObjectContext context, DbConnection connection, List <EntitySet> modelTables, string edmMetadataContextTableName)
{
var modelTablesListBuilder = new StringBuilder();
foreach (var modelTable in modelTables)
{
modelTablesListBuilder.Append("'");
modelTablesListBuilder.Append(GetTableName(modelTable));
modelTablesListBuilder.Append("',");
}
modelTablesListBuilder.Append("'");
modelTablesListBuilder.Append("edmMetadataContextTableName");
modelTablesListBuilder.Append("'");
using (var command = new InterceptableDbCommand(
connection.CreateCommand(), context.InterceptionContext))
{
command.CommandText = @"
SELECT Count(*)
FROM INFORMATION_SCHEMA.TABLES AS t
WHERE t.TABLE_TYPE = 'TABLE'
AND t.TABLE_NAME IN (" + modelTablesListBuilder + @")";
var executionStrategy = DbProviderServices.GetExecutionStrategy(connection);
try
{
return(executionStrategy.Execute(
() =>
{
if (connection.State == ConnectionState.Broken)
{
connection.Close();
}
if (connection.State == ConnectionState.Closed)
{
connection.Open();
}
return (int)command.ExecuteScalar() > 0;
}));
}
finally
{
if (connection.State != ConnectionState.Closed)
{
connection.Close();
}
}
}
}
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());
}
private static IEnumerable <Tuple <string, string> > GetDatabaseTables(
ObjectContext context, DbConnection connection, IPseudoProvider provider)
{
using (var command = new InterceptableDbCommand(
connection.CreateCommand(), context.InterceptionContext))
{
command.CommandText = provider.StoreSchemaTablesQuery;
var executionStrategy = DbProviderServices.GetExecutionStrategy(connection);
try
{
return(executionStrategy.Execute(
() =>
{
if (connection.State == ConnectionState.Broken)
{
connection.Close();
}
if (connection.State == ConnectionState.Closed)
{
connection.Open();
}
using (var reader = command.ExecuteReader())
{
var tables = new List <Tuple <string, string> >();
while (reader.Read())
{
tables.Add(
Tuple.Create(
reader["SchemaName"] as string,
reader["Name"] as string));
}
return tables;
}
}));
}
finally
{
if (connection.State != ConnectionState.Closed)
{
connection.Close();
}
}
}
}
public void ExecuteNonQueryAsync_should_dispatch_to_interceptor_and_optionally_execute()
{
var mockCommand = new Mock <DbCommand>();
var result = new Task <int>(() => 11);
mockCommand.Setup(m => m.ExecuteNonQueryAsync(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.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.AsyncNonQueryExecuting(It.IsAny <DbCommand>(), It.IsAny <DbInterceptionContext>()), Times.Never());
mockPublicInterceptor.Verify(
m => m.AsyncNonQueryExecuted(It.IsAny <DbCommand>(), It.IsAny <Task <int> >(), It.IsAny <DbInterceptionContext>()), Times.Never());
mockCancelable.Setup(m => m.CommandExecuting(mockCommand.Object, interceptionContext)).Returns(true);
Assert.Same(result, interceptableDbCommand.ExecuteNonQueryAsync());
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.AsyncNonQueryExecuting(mockCommand.Object, interceptionContext), Times.Once());
mockPublicInterceptor.Verify(
m => m.AsyncNonQueryExecuted(mockCommand.Object, result, interceptionContext), Times.Once());
}
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 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 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 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);
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 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 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());
}
private DbCommand PrepareEntityCommandBeforeExecution(EntityCommand entityCommand)
{
if (1 != _mappedCommandDefinitions.Count)
{
throw new NotSupportedException("MARS");
}
var entityTransaction = entityCommand.ValidateAndGetEntityTransaction();
var definition = _mappedCommandDefinitions[0];
var storeProviderCommand = new InterceptableDbCommand(definition.CreateCommand(), entityCommand.InterceptionContext);
CommandHelper.SetStoreProviderCommandState(entityCommand, entityTransaction, storeProviderCommand);
// Copy over the values from the map command to the store command; we
// assume that they were not renamed by either the plan compiler or SQL
// Generation.
//
// Note that this pretty much presumes that named parameters are supported
// by the store provider, but it might work if we don't reorder/reuse
// parameters.
//
// Note also that the store provider may choose to add parameters to thier
// command object for some things; we'll only copy over the values for
// parameters that we find in the EntityCommands parameters collection, so
// we won't damage anything the store provider did.
var hasOutputParameters = false;
// Could be null for some providers, don't remove this check
if (storeProviderCommand.Parameters != null)
{
foreach (DbParameter storeParameter in storeProviderCommand.Parameters)
{
// I could just use the string indexer, but then if I didn't find it the
// consumer would get some ParameterNotFound exeception message and that
// wouldn't be very meaningful. Instead, I use the IndexOf method and
// if I don't find it, it's not a big deal (The store provider must
// have added it).
var parameterOrdinal = entityCommand.Parameters.IndexOf(storeParameter.ParameterName);
if (-1 != parameterOrdinal)
{
var entityParameter = entityCommand.Parameters[parameterOrdinal];
// _storeProviderServices will be null if this object was created via
// the test constructor - but if so we shouldn't be calling this
DebugCheck.NotNull(_storeProviderServices);
SyncParameterProperties(entityParameter, storeParameter, _storeProviderServices);
if (storeParameter.Direction
!= ParameterDirection.Input)
{
hasOutputParameters = true;
}
}
}
}
// If the EntityCommand has output parameters, we must synchronize parameter values when
// the reader is closed. Tell the EntityCommand about the store command so that it knows
// where to pull those values from.
if (hasOutputParameters)
{
entityCommand.SetStoreProviderCommand(storeProviderCommand);
}
return storeProviderCommand;
}
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 <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);
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 <CommandBehavior>(),
It.IsAny <DbInterceptionContext>()), Times.Never());
mockPublicInterceptor.Verify(
m => m.ReaderExecuted(
It.IsAny <DbCommand>(),
It.IsAny <CommandBehavior>(),
It.IsAny <DbDataReader>(),
It.IsAny <DbInterceptionContext>()), Times.Never());
mockCancelable.Setup(m => m.CommandExecuting(mockCommand.Object, interceptionContext)).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, CommandBehavior.SingleRow, interceptionContext), Times.Once());
mockPublicInterceptor.Verify(
m => m.ReaderExecuted(mockCommand.Object, CommandBehavior.SingleRow, mockReader.Object, interceptionContext), Times.Once());
}
public void ExecuteNonQueryAsync_should_dispatch_to_interceptor_and_optionally_execute()
{
var mockCommand = new Mock<DbCommand>();
var result = new Task<int>(() => 11);
mockCommand.Setup(m => m.ExecuteNonQueryAsync(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.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.AsyncNonQueryExecuting(It.IsAny<DbCommand>(), It.IsAny<DbInterceptionContext>()), Times.Never());
mockPublicInterceptor.Verify(
m => m.AsyncNonQueryExecuted(It.IsAny<DbCommand>(), It.IsAny<Task<int>>(), It.IsAny<DbInterceptionContext>()), Times.Never());
mockCancelable.Setup(m => m.CommandExecuting(mockCommand.Object, interceptionContext)).Returns(true);
Assert.Same(result, interceptableDbCommand.ExecuteNonQueryAsync());
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.AsyncNonQueryExecuting(mockCommand.Object, interceptionContext), Times.Once());
mockPublicInterceptor.Verify(
m => m.AsyncNonQueryExecuted(mockCommand.Object, result, interceptionContext), 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<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);
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<CommandBehavior>(),
It.IsAny<DbInterceptionContext>()), Times.Never());
mockPublicInterceptor.Verify(
m => m.ReaderExecuted(
It.IsAny<DbCommand>(),
It.IsAny<CommandBehavior>(),
It.IsAny<DbDataReader>(),
It.IsAny<DbInterceptionContext>()), Times.Never());
mockCancelable.Setup(m => m.CommandExecuting(mockCommand.Object, interceptionContext)).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, CommandBehavior.SingleRow, interceptionContext), Times.Once());
mockPublicInterceptor.Verify(
m => m.ReaderExecuted(mockCommand.Object, CommandBehavior.SingleRow, mockReader.Object, interceptionContext), Times.Once());
}