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