public async Task Can_open_the_underlying_connection(bool async)
{
var dbConnection = new FakeDbConnection("A=B");
var context = RelationalTestHelpers.Instance.CreateContext();
((FakeRelationalConnection)context.GetService <IRelationalConnection>()).UseConnection(dbConnection);
if (async)
{
await context.Database.OpenConnectionAsync();
Assert.Equal(1, dbConnection.OpenAsyncCount);
}
else
{
context.Database.OpenConnection();
Assert.Equal(1, dbConnection.OpenCount);
}
}
public void Can_use_existing_transaction()
{
var dbConnection = new FakeDbConnection("Database=FrodoLives");
var dbTransaction = dbConnection.BeginTransaction(IsolationLevel.Unspecified);
using (var connection = new FakeRelationalConnection(
CreateOptions(new FakeRelationalOptionsExtension().WithConnection(dbConnection))))
{
Assert.Null(connection.CurrentTransaction);
using (connection.UseTransaction(dbTransaction))
{
Assert.Equal(dbTransaction, connection.CurrentTransaction.GetDbTransaction());
}
Assert.Null(connection.CurrentTransaction);
}
}
public void GetDbTransaction_returns_the_DbTransaction()
{
var dbConnection = new FakeDbConnection(ConnectionString);
var dbTransaction = new FakeDbTransaction(dbConnection);
var connection = new FakeRelationalConnection(
CreateOptions(new FakeRelationalOptionsExtension {
Connection = dbConnection
}));
var transaction = new RelationalTransaction(
connection,
dbTransaction,
new ListLogger(new List <Tuple <LogLevel, string> >()),
new DiagnosticListener("Fake"),
false);
Assert.Equal(dbTransaction, transaction.GetDbTransaction());
}
public void ShouldThrowExceptionWhenCreateTableCommandDoesNotReturnZero()
{
// Given
var connection = new FakeDbConnection(openConnection: true);
var language = new FakeDbLanguage();
var database = new Database <FakeDbConnection, FakeDbLanguage>(connection, language);
var table = new TableMetaData <TestEntity>();
connection.CreateCommandFactory = () => new FakeDbCommand()
{
ReturnValueForExecuteNonQuery = 1
};
// When
Action action = () => database.CreateTable(table);
// Then
action.ShouldThrow <Exception>().WithMessage("CREATE TABLE returned 1. Expected value to be 0.");
}
public virtual async Task Can_ExecuteNonQueryAsync(bool manageConnection)
{
var executeNonQueryCount = 0;
var disposeCount = -1;
var fakeDbConnection = new FakeDbConnection(
ConnectionString,
new FakeCommandExecutor(
executeNonQueryAsync: (c, ct) =>
{
executeNonQueryCount++;
disposeCount = c.DisposeCount;
return(Task.FromResult(1));
}));
var optionsExtension = new FakeRelationalOptionsExtension {
Connection = fakeDbConnection
};
var options = CreateOptions(optionsExtension);
var fakeConnection = new FakeRelationalConnection(options);
var relationalCommand = new RelationalCommand(
new FakeSensitiveDataLogger <RelationalCommand>(),
new DiagnosticListener("Fake"),
"ExecuteNonQuery Command",
new RelationalParameter[0]);
await relationalCommand.ExecuteNonQueryAsync(fakeConnection, manageConnection : manageConnection);
var expectedCount = manageConnection ? 1 : 0;
Assert.Equal(expectedCount, fakeDbConnection.OpenCount);
Assert.Equal(expectedCount, fakeDbConnection.CloseCount);
// Durring command execution
Assert.Equal(1, executeNonQueryCount);
Assert.Equal(0, disposeCount);
// After command execution
Assert.Equal(1, fakeDbConnection.DbCommands[0].DisposeCount);
}
public async Task Does_not_close_unmanaged_connections_on_exception(
Delegate commandDelegate,
string telemetryName,
bool async)
{
var exception = new InvalidOperationException();
var fakeDbConnection = new FakeDbConnection(
ConnectionString,
new FakeCommandExecutor(
c => { throw exception; },
c => { throw exception; },
(c, cb) => { throw exception; },
(c, ct) => { throw exception; },
(c, ct) => { throw exception; },
(c, cb, ct) => { throw exception; }));
var optionsExtension = new FakeRelationalOptionsExtension().WithConnection(fakeDbConnection);
var options = CreateOptions(optionsExtension);
var fakeConnection = new FakeRelationalConnection(options);
var relationalCommand = CreateRelationalCommand();
if (async)
{
await Assert.ThrowsAsync <InvalidOperationException>(
async()
=> await((CommandFunc)commandDelegate)(fakeConnection, relationalCommand, null));
Assert.Equal(1, fakeDbConnection.OpenAsyncCount);
}
else
{
Assert.Throws <InvalidOperationException>(()
=> ((CommandAction)commandDelegate)(fakeConnection, relationalCommand, null));
Assert.Equal(1, fakeDbConnection.OpenCount);
}
Assert.Equal(1, fakeDbConnection.CloseCount);
}
public void Existing_connection_is_opened_and_closed_when_necessary()
{
var dbConnection = new FakeDbConnection("Database=FrodoLives");
using (var connection = new FakeRelationalConnection(
CreateOptions(new FakeRelationalOptionsExtension {
Connection = dbConnection
})))
{
Assert.Equal(0, connection.DbConnections.Count);
connection.Open();
Assert.Equal(0, connection.DbConnections.Count);
Assert.Equal(1, dbConnection.OpenCount);
connection.Open();
connection.Open();
Assert.Equal(1, dbConnection.OpenCount);
connection.Close();
connection.Close();
Assert.Equal(1, dbConnection.OpenCount);
Assert.Equal(0, dbConnection.CloseCount);
connection.Close();
Assert.Equal(1, dbConnection.OpenCount);
Assert.Equal(1, dbConnection.CloseCount);
connection.Open();
Assert.Equal(2, dbConnection.OpenCount);
connection.Close();
Assert.Equal(2, dbConnection.OpenCount);
Assert.Equal(2, dbConnection.CloseCount);
}
}
public void Existing_connection_can_start_in_opened_state()
{
var dbConnection = new FakeDbConnection(
"Database=FrodoLives",
state: ConnectionState.Open);
using (var connection = new FakeRelationalConnection(
CreateOptions(new FakeRelationalOptionsExtension().WithConnection(dbConnection))))
{
Assert.Equal(0, connection.DbConnections.Count);
connection.Open();
Assert.Equal(0, connection.DbConnections.Count);
Assert.Equal(0, dbConnection.OpenCount);
connection.Open();
connection.Open();
Assert.Equal(0, dbConnection.OpenCount);
connection.Close();
connection.Close();
Assert.Equal(0, dbConnection.OpenCount);
Assert.Equal(0, dbConnection.CloseCount);
connection.Close();
Assert.Equal(0, dbConnection.OpenCount);
Assert.Equal(0, dbConnection.CloseCount);
connection.Open();
Assert.Equal(0, dbConnection.OpenCount);
connection.Close();
Assert.Equal(0, dbConnection.OpenCount);
Assert.Equal(0, dbConnection.CloseCount);
}
}
public async Task Disposes_transaction_on_exception(bool async)
{
var fakeDbConnection =
new FakeDbConnection(
ConnectionString,
new FakeCommandExecutor(
executeNonQuery: c => { throw new InvalidOperationException(); },
executeNonQueryAsync: (c, ct) => { throw new InvalidOperationException(); }));
var fakeConnection =
CreateConnection(
CreateOptions(
new FakeRelationalOptionsExtension().WithConnection(fakeDbConnection)));
var commandList = new List <MigrationCommand>
{
new MigrationCommand(CreateRelationalCommand())
};
var migrationCommandExecutor = new MigrationCommandExecutor();
if (async)
{
await Assert.ThrowsAsync <InvalidOperationException>(
async()
=> await migrationCommandExecutor.ExecuteNonQueryAsync(commandList, fakeConnection));
}
else
{
Assert.Throws <InvalidOperationException>(
()
=> migrationCommandExecutor.ExecuteNonQuery(commandList, fakeConnection));
}
Assert.Equal(1, fakeDbConnection.OpenCount);
Assert.Equal(1, fakeDbConnection.CloseCount);
Assert.Equal(1, fakeDbConnection.DbTransactions.Count);
Assert.Equal(1, fakeDbConnection.DbTransactions[0].DisposeCount);
Assert.Equal(0, fakeDbConnection.DbTransactions[0].CommitCount);
Assert.Equal(0, fakeDbConnection.DbTransactions[0].RollbackCount);
}
public void ShouldThrowExceptionWhenInsertTableCommandDoesNotReturnOne()
{
// Given
var connection = new FakeDbConnection()
{
CreateCommandFactory = () => new FakeDbCommand()
{
ReturnValueForExecuteNonQuery = 0
}
};
var language = new FakeDbLanguage();
var database = new Database <FakeDbConnection, FakeDbLanguage>(connection, language);
var row = new TestEntity();
// When
Action action = () => database.Insert(row);
// Then
action.ShouldThrow <Exception>().WithMessage("INSERT returned 0. Expected value to be 1.");
}
public async Task Disposes_command_on_exception(
Delegate commandDelegate,
string telemetryName,
bool async)
{
var exception = new InvalidOperationException();
var fakeDbConnection = new FakeDbConnection(
ConnectionString,
new FakeCommandExecutor(
c => { throw exception; },
c => { throw exception; },
(c, cb) => { throw exception; },
(c, ct) => { throw exception; },
(c, ct) => { throw exception; },
(c, cb, ct) => { throw exception; }));
var optionsExtension = new FakeRelationalOptionsExtension {
Connection = fakeDbConnection
};
var options = CreateOptions(optionsExtension);
var fakeConnection = new FakeRelationalConnection(options);
var relationalCommand = CreateRelationalCommand();
if (async)
{
await Assert.ThrowsAsync <InvalidOperationException>(
async()
=> await((CommandFunc)commandDelegate)(fakeConnection, relationalCommand, null, true));
}
else
{
Assert.Throws <InvalidOperationException>(()
=> ((CommandAction)commandDelegate)(fakeConnection, relationalCommand, null, true));
}
Assert.Equal(1, fakeDbConnection.DbCommands[0].DisposeCount);
}
public async Task Can_ExecuteScalarAsync(bool manageConnection)
{
var executeScalarCount = 0;
var disposeCount = -1;
var fakeDbConnection = new FakeDbConnection(
ConnectionString,
new FakeCommandExecutor(
executeScalarAsync: (c, ct) =>
{
executeScalarCount++;
disposeCount = c.DisposeCount;
return(Task.FromResult <object>("ExecuteScalar Result"));
}));
var optionsExtension = new FakeRelationalOptionsExtension {
Connection = fakeDbConnection
};
var options = CreateOptions(optionsExtension);
var relationalCommand = CreateRelationalCommand();
var result = (string)await relationalCommand.ExecuteScalarAsync(
new FakeRelationalConnection(options),
manageConnection : manageConnection);
Assert.Equal("ExecuteScalar Result", result);
var expectedCount = manageConnection ? 1 : 0;
Assert.Equal(expectedCount, fakeDbConnection.OpenCount);
Assert.Equal(expectedCount, fakeDbConnection.CloseCount);
// Durring command execution
Assert.Equal(1, executeScalarCount);
Assert.Equal(0, disposeCount);
// After command execution
Assert.Equal(1, fakeDbConnection.DbCommands[0].DisposeCount);
}
public void Can_ExecuteNonQuery(bool manageConnection)
{
var executeNonQueryCount = 0;
var disposeCount = -1;
var fakeDbConnection = new FakeDbConnection(
ConnectionString,
new FakeCommandExecutor(
executeNonQuery: c =>
{
executeNonQueryCount++;
disposeCount = c.DisposeCount;
return(1);
}));
var optionsExtension = new FakeRelationalOptionsExtension {
Connection = fakeDbConnection
};
var options = CreateOptions(optionsExtension);
var relationalCommand = CreateRelationalCommand();
var result = relationalCommand.ExecuteNonQuery(
new FakeRelationalConnection(options),
manageConnection: manageConnection);
Assert.Equal(1, result);
var expectedCount = manageConnection ? 1 : 0;
Assert.Equal(expectedCount, fakeDbConnection.OpenCount);
Assert.Equal(expectedCount, fakeDbConnection.CloseCount);
// Durring command execution
Assert.Equal(1, executeNonQueryCount);
Assert.Equal(0, disposeCount);
// After command execution
Assert.Equal(1, fakeDbConnection.DbCommands[0].DisposeCount);
}
public void GetDbTransaction_returns_the_DbTransaction()
{
var dbConnection = new FakeDbConnection(ConnectionString);
var dbTransaction = new FakeDbTransaction(dbConnection);
var connection = new FakeRelationalConnection(
CreateOptions((FakeRelationalOptionsExtension) new FakeRelationalOptionsExtension().WithConnection(dbConnection)));
var loggerFactory = new ListLoggerFactory();
var transaction = new RelationalTransaction(
connection,
dbTransaction,
new DiagnosticsLogger <DbLoggerCategory.Database.Transaction>(
loggerFactory,
new LoggingOptions(),
new DiagnosticListener("Fake")),
false);
Assert.Equal(dbTransaction, transaction.GetDbTransaction());
}
public void ShouldInsertRow()
{
// Given
var connection = new FakeDbConnection()
{
CreateCommandFactory = () => new FakeDbCommand()
{
ReturnValueForExecuteNonQuery = 1
}
};
var language = new FakeDbLanguage();
var database = new Database <FakeDbConnection, FakeDbLanguage>(connection, language);
var row = new TestEntity();
// When
database.Insert(row);
// Then
var command = connection.Commands.Single();
command.CommandText.Should().Be(FormatCommandText(
@"INSERT INTO *TestEntities* (
*RequiredInt*,
*NullableInt*,
*RequiredString*,
*NullableString*
)
VALUES (
#RequiredInt,
#NullableInt,
#RequiredString,
#NullableString
);"
));
var parameterNames = from p in command.Parameters.Cast <IDbDataParameter>()
select p.ParameterName;
parameterNames.ShouldBeEquivalentTo(new string[] { "#RequiredInt", "#NullableInt", "#RequiredString", "#NullableString" });
}
public virtual async Task Can_ExecuteNonQueryAsync()
{
var executeNonQueryCount = 0;
var disposeCount = -1;
var fakeDbConnection = new FakeDbConnection(
ConnectionString,
new FakeCommandExecutor(
executeNonQueryAsync: (c, ct) =>
{
executeNonQueryCount++;
disposeCount = c.DisposeCount;
return(Task.FromResult(1));
}));
var optionsExtension = new FakeRelationalOptionsExtension {
Connection = fakeDbConnection
};
var options = CreateOptions(optionsExtension);
var relationalCommand = CreateRelationalCommand();
var result = await relationalCommand.ExecuteNonQueryAsync(
new FakeRelationalConnection(options));
Assert.Equal(1, result);
var expectedCount = 1;
Assert.Equal(expectedCount, fakeDbConnection.OpenCount);
Assert.Equal(expectedCount, fakeDbConnection.CloseCount);
// Durring command execution
Assert.Equal(1, executeNonQueryCount);
Assert.Equal(0, disposeCount);
// After command execution
Assert.Equal(1, fakeDbConnection.DbCommands[0].DisposeCount);
}
public void Can_ExecuteScalar()
{
var executeScalarCount = 0;
var disposeCount = -1;
var fakeDbConnection = new FakeDbConnection(
ConnectionString,
new FakeCommandExecutor(
executeScalar: c =>
{
executeScalarCount++;
disposeCount = c.DisposeCount;
return("ExecuteScalar Result");
}));
var optionsExtension = new FakeRelationalOptionsExtension {
Connection = fakeDbConnection
};
var options = CreateOptions(optionsExtension);
var relationalCommand = CreateRelationalCommand();
var result = (string)relationalCommand.ExecuteScalar(
new FakeRelationalConnection(options));
Assert.Equal("ExecuteScalar Result", result);
var expectedCount = 1;
Assert.Equal(expectedCount, fakeDbConnection.OpenCount);
Assert.Equal(expectedCount, fakeDbConnection.CloseCount);
// Durring command execution
Assert.Equal(1, executeScalarCount);
Assert.Equal(0, disposeCount);
// After command execution
Assert.Equal(1, fakeDbConnection.DbCommands[0].DisposeCount);
}
public void SimpleExample()
{
// This is the result we want to return when execute reader is executed
var fakeDataReader = new FakeDataReader(0,"UserId","Name");
fakeDataReader.AddRow(1, "Smith");
fakeDataReader.AddRow(2, "John");
var result = new List<User>();
using (var connection = new FakeDbConnection("ConnectionString", dbCommand => fakeDataReader))
{
connection.Open();
using (IDbCommand command = connection.CreateCommand())
{
command.CommandText = "SELECT * FROM Users";
IDbDataParameter dbDataParameter = command.CreateParameter();
dbDataParameter.ParameterName = "ParameterName";
dbDataParameter.DbType = DbType.Int32;
dbDataParameter.Value = 0;
command.Parameters.Add(dbDataParameter);
using (IDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
result.Add(new User { UserId = reader.GetInt32(0), Name = reader.GetString(1)});
}
}
}
}
Assert.That(result.Count, Is.EqualTo(2));
Assert.That(result.ElementAt(0).UserId, Is.EqualTo(1));
Assert.That(result.ElementAt(0).Name, Is.EqualTo("Smith"));
Assert.That(result.ElementAt(1).UserId, Is.EqualTo(2));
Assert.That(result.ElementAt(1).Name, Is.EqualTo("John"));
}
public void Can_ExecuteNonQuery()
{
var executeNonQueryCount = 0;
var disposeCount = -1;
var fakeDbConnection = new FakeDbConnection(
ConnectionString,
new FakeCommandExecutor(
executeNonQuery: c =>
{
executeNonQueryCount++;
disposeCount = c.DisposeCount;
return(1);
}));
var optionsExtension = new FakeRelationalOptionsExtension().WithConnection(fakeDbConnection);
var options = CreateOptions(optionsExtension);
var relationalCommand = CreateRelationalCommand();
var result = relationalCommand.ExecuteNonQuery(
new RelationalCommandParameterObject(
new FakeRelationalConnection(options), null, null, null));
Assert.Equal(1, result);
var expectedCount = 1;
Assert.Equal(expectedCount, fakeDbConnection.OpenCount);
Assert.Equal(expectedCount, fakeDbConnection.CloseCount);
// During command execution
Assert.Equal(1, executeNonQueryCount);
Assert.Equal(0, disposeCount);
// After command execution
Assert.Equal(1, fakeDbConnection.DbCommands[0].DisposeCount);
}
public void ShouldIdAfterPreviousInsert()
{
// Given
var expectedLastId = 123;
var connection = new FakeDbConnection()
{
CreateCommandFactory = () => new FakeDbCommand()
{
ReturnValueForExecuteScalar = expectedLastId
}
};
var language = new FakeDbLanguage();
var database = new Database <FakeDbConnection, FakeDbLanguage>(connection, language);
// When
var lastId = database.GetLastId <TestEntity>();
// Then
var command = connection.Commands.Single();
lastId.Should().Be(expectedLastId);
command.CommandText.Should().Be("SELECT #GetLastId;");
}
public void Existing_connection_can_be_changed_and_reset()
{
var dbConnection = new FakeDbConnection("Database=FrodoLives");
using var connection = new FakeRelationalConnection(
CreateOptions(new FakeRelationalOptionsExtension().WithConnection(dbConnection)));
Assert.Equal(0, connection.DbConnections.Count);
connection.DbConnection = null;
Assert.Null(connection.ConnectionString);
dbConnection = new FakeDbConnection("Database=SamLives");
connection.DbConnection = dbConnection;
Assert.Equal("Database=SamLives", connection.ConnectionString);
Assert.Equal(0, connection.DbConnections.Count);
Assert.Same(dbConnection, connection.DbConnection);
Assert.Equal(0, connection.DbConnections.Count);
Assert.Equal("Database=SamLives", connection.ConnectionString);
connection.DbConnection = null;
Assert.Equal(0, connection.DbConnections.Count);
Assert.Null(connection.ConnectionString);
connection.ConnectionString = "Database=MerryLives";
dbConnection = new FakeDbConnection("Database=MerryLives");
connection.DbConnection = dbConnection;
Assert.Equal(0, connection.DbConnections.Count);
Assert.Same(dbConnection, connection.DbConnection);
Assert.Equal(0, connection.DbConnections.Count);
Assert.Equal("Database=MerryLives", connection.ConnectionString);
}
public void ShouldCreateTable()
{
// Given
var connection = new FakeDbConnection(openConnection: true);
var language = new FakeDbLanguage();
var database = new Database <FakeDbConnection, FakeDbLanguage>(connection, language);
var table = new TableMetaData <TestEntity>();
// When
database.CreateTable(table);
// Then
var command = connection.Commands.Single();
command.CommandText.Should().Be(FormatCommandText(
@"CREATE TABLE *TestEntities* (
*Id* Int32 NOT NULL PRIMARY KEY,
*RequiredInt* Int32 NOT NULL,
*NullableInt* Nullable`1[[Int32]],
*RequiredString* String NOT NULL,
*NullableString* String
);"
));
}
public void Existing_connection_can_be_opened_and_closed_externally()
{
var dbConnection = new FakeDbConnection(
"Database=FrodoLives");
using var connection = new FakeRelationalConnection(
CreateOptions(new FakeRelationalOptionsExtension().WithConnection(dbConnection)));
Assert.Equal(0, connection.DbConnections.Count);
connection.Open();
Assert.Equal(0, connection.DbConnections.Count);
Assert.Equal(1, dbConnection.OpenCount);
connection.Close();
Assert.Equal(1, dbConnection.OpenCount);
Assert.Equal(1, dbConnection.CloseCount);
dbConnection.SetState(ConnectionState.Open);
connection.Open();
Assert.Equal(1, dbConnection.OpenCount);
Assert.Equal(1, dbConnection.CloseCount);
connection.Close();
Assert.Equal(1, dbConnection.OpenCount);
Assert.Equal(1, dbConnection.CloseCount);
dbConnection.SetState(ConnectionState.Closed);
connection.Open();
Assert.Equal(2, dbConnection.OpenCount);
Assert.Equal(1, dbConnection.CloseCount);
connection.Close();
Assert.Equal(2, dbConnection.OpenCount);
Assert.Equal(2, dbConnection.CloseCount);
dbConnection.SetState(ConnectionState.Open);
connection.Open();
Assert.Equal(2, dbConnection.OpenCount);
Assert.Equal(2, dbConnection.CloseCount);
dbConnection.SetState(ConnectionState.Closed);
connection.Close();
Assert.Equal(2, dbConnection.OpenCount);
Assert.Equal(2, dbConnection.CloseCount);
connection.Open();
connection.Open();
Assert.Equal(3, dbConnection.OpenCount);
dbConnection.SetState(ConnectionState.Closed);
connection.Open();
Assert.Equal(4, dbConnection.OpenCount);
Assert.Equal(2, dbConnection.CloseCount);
dbConnection.SetState(ConnectionState.Closed);
connection.Close();
Assert.Equal(4, dbConnection.OpenCount);
Assert.Equal(2, dbConnection.CloseCount);
}
public static FakeDbConnectionAssertions Should(this FakeDbConnection instance)
{
return(new FakeDbConnectionAssertions(instance));
}
public async Task Existing_connection_can_be_opened_and_closed_externally_async()
{
var dbConnection = new FakeDbConnection(
"Database=FrodoLives",
state: ConnectionState.Closed);
using (var connection = new FakeRelationalConnection(
CreateOptions(new FakeRelationalOptionsExtension {
Connection = dbConnection
})))
{
Assert.Equal(0, connection.DbConnections.Count);
await connection.OpenAsync();
Assert.Equal(0, connection.DbConnections.Count);
Assert.Equal(1, dbConnection.OpenCount);
connection.Close();
Assert.Equal(1, dbConnection.OpenCount);
Assert.Equal(1, dbConnection.CloseCount);
dbConnection.SetState(ConnectionState.Open);
await connection.OpenAsync();
Assert.Equal(1, dbConnection.OpenCount);
Assert.Equal(1, dbConnection.CloseCount);
connection.Close();
Assert.Equal(1, dbConnection.OpenCount);
Assert.Equal(1, dbConnection.CloseCount);
dbConnection.SetState(ConnectionState.Closed);
await connection.OpenAsync();
Assert.Equal(2, dbConnection.OpenCount);
Assert.Equal(1, dbConnection.CloseCount);
connection.Close();
Assert.Equal(2, dbConnection.OpenCount);
Assert.Equal(2, dbConnection.CloseCount);
dbConnection.SetState(ConnectionState.Open);
await connection.OpenAsync();
Assert.Equal(2, dbConnection.OpenCount);
Assert.Equal(2, dbConnection.CloseCount);
dbConnection.SetState(ConnectionState.Closed);
connection.Close();
Assert.Equal(2, dbConnection.OpenCount);
Assert.Equal(2, dbConnection.CloseCount);
await connection.OpenAsync();
await connection.OpenAsync();
Assert.Equal(3, dbConnection.OpenCount);
dbConnection.SetState(ConnectionState.Closed);
await connection.OpenAsync();
Assert.Equal(4, dbConnection.OpenCount);
Assert.Equal(2, dbConnection.CloseCount);
dbConnection.SetState(ConnectionState.Closed);
connection.Close();
Assert.Equal(4, dbConnection.OpenCount);
Assert.Equal(2, dbConnection.CloseCount);
}
}
public async Task Reports_command_diagnostic_on_exception(
Delegate commandDelegate,
string diagnosticName,
bool async)
{
var exception = new InvalidOperationException();
var fakeDbConnection = new FakeDbConnection(
ConnectionString,
new FakeCommandExecutor(
c => { throw exception; },
c => { throw exception; },
(c, cb) => { throw exception; },
(c, ct) => { throw exception; },
(c, ct) => { throw exception; },
(c, cb, ct) => { throw exception; }));
var optionsExtension = new FakeRelationalOptionsExtension {
Connection = fakeDbConnection
};
var options = CreateOptions(optionsExtension);
var fakeConnection = new FakeRelationalConnection(options);
var diagnostic = new List <Tuple <string, object> >();
var relationalCommand = new RelationalCommand(
new SensitiveDataLogger <RelationalCommand>(
new FakeSensitiveDataLogger <RelationalCommand>(),
options),
new ListDiagnosticSource(diagnostic),
"Command Text",
new[]
{
new RelationalParameter("FirstParameter", 17, new RelationalTypeMapping("int", typeof(int), DbType.Int32), false, null)
});
if (async)
{
await Assert.ThrowsAsync <InvalidOperationException>(
async()
=> await((Func <RelationalCommand, bool, IRelationalConnection, Task>)commandDelegate)(relationalCommand, true, fakeConnection));
}
else
{
Assert.Throws <InvalidOperationException>(()
=> ((Action <RelationalCommand, bool, IRelationalConnection>)commandDelegate)(relationalCommand, true, fakeConnection));
}
Assert.Equal(2, diagnostic.Count);
Assert.Equal(RelationalDiagnostics.BeforeExecuteCommand, diagnostic[0].Item1);
Assert.Equal(RelationalDiagnostics.CommandExecutionError, diagnostic[1].Item1);
var beforeData = (RelationalDiagnosticSourceMessage)diagnostic[0].Item2;
var afterData = (RelationalDiagnosticSourceMessage)diagnostic[1].Item2;
Assert.Equal(fakeDbConnection.DbCommands[0], beforeData.Command);
Assert.Equal(fakeDbConnection.DbCommands[0], afterData.Command);
Assert.Equal(diagnosticName, beforeData.ExecuteMethod);
Assert.Equal(diagnosticName, afterData.ExecuteMethod);
Assert.Equal(async, beforeData.IsAsync);
Assert.Equal(async, afterData.IsAsync);
Assert.Equal(exception, afterData.Exception);
}
public async Task Reports_command_diagnostic_on_exception(
Delegate commandDelegate,
string diagnosticName,
bool async)
{
var exception = new InvalidOperationException();
var fakeDbConnection = new FakeDbConnection(
ConnectionString,
new FakeCommandExecutor(
c => { throw exception; },
c => { throw exception; },
(c, cb) => { throw exception; },
(c, ct) => { throw exception; },
(c, ct) => { throw exception; },
(c, cb, ct) => { throw exception; }));
var optionsExtension = new FakeRelationalOptionsExtension {
Connection = fakeDbConnection
};
var options = CreateOptions(optionsExtension);
var diagnostic = new List <Tuple <string, object> >();
var fakeConnection = new FakeRelationalConnection(options);
var relationalCommand = CreateRelationalCommand(
diagnosticSource: new ListDiagnosticSource(diagnostic),
parameters: new[]
{
new TypeMappedRelationalParameter("FirstInvariant", "FirstParameter", new RelationalTypeMapping("int", typeof(int), DbType.Int32), false)
});
var parameterValues = new Dictionary <string, object>
{
{ "FirstInvariant", 17 }
};
if (async)
{
await Assert.ThrowsAsync <InvalidOperationException>(
async()
=> await((CommandFunc)commandDelegate)(fakeConnection, relationalCommand, parameterValues));
}
else
{
Assert.Throws <InvalidOperationException>(()
=> ((CommandAction)commandDelegate)(fakeConnection, relationalCommand, parameterValues));
}
Assert.Equal(2, diagnostic.Count);
Assert.Equal(RelationalDiagnostics.BeforeExecuteCommand, diagnostic[0].Item1);
Assert.Equal(RelationalDiagnostics.CommandExecutionError, diagnostic[1].Item1);
var beforeData = (RelationalDiagnosticSourceBeforeMessage)diagnostic[0].Item2;
var afterData = (RelationalDiagnosticSourceAfterMessage)diagnostic[1].Item2;
Assert.Equal(fakeDbConnection.DbCommands[0], beforeData.Command);
Assert.Equal(fakeDbConnection.DbCommands[0], afterData.Command);
Assert.Equal(diagnosticName, beforeData.ExecuteMethod);
Assert.Equal(diagnosticName, afterData.ExecuteMethod);
Assert.Equal(async, beforeData.IsAsync);
Assert.Equal(async, afterData.IsAsync);
Assert.Equal(exception, afterData.Exception);
}
public async Task Proxy_UpdateAsync_should_work_identically_to_Update()
{
List <TestTable> randomDataSource = RandomDataGenerator.CreateRandomTables(seed: 1234, tableCount: 5, /*allowZeroRowsInTablesByIdx: */ 1, 3);
// Part 1: Use proxy
DataSet dataSetFromProxy;
{
using (FakeDbConnection connection = new FakeDbConnection(asyncMode: AsyncMode.AwaitAsync))
using (FakeDbCommand selectCommand = connection.CreateCommand(testTables: randomDataSource))
{
await connection.OpenAsync();
using (BatchingFakeProxiedDbDataAdapter adapter = new BatchingFakeProxiedDbDataAdapter(selectCommand))
using (DbCommandBuilder cmdBuilder = await adapter.CreateCommandBuilderAsync().ConfigureAwait(false))
{
dataSetFromProxy = new DataSet();
// `.Fill` returns the number of rows in the first table, not any subsequent tables. Yes, that's silly.
Int32 rowsInFirstTable = await adapter.FillAsync(dataSetFromProxy);
rowsInFirstTable.ShouldBe(40);
//
Dictionary <String, Int32> rowsModified = DataTableMethods.MutateDataSet(dataSetFromProxy);
//
adapter.UpdateCommand = (FakeDbCommand)cmdBuilder.GetUpdateCommand();
adapter.UpdateCommand.NonQueryResultRowCountValue = (cmd) => 1; // HACK /* DataTableMethods.GetNonQueryResultRowCountValue( dataSetFromProxy, cmd, rowsModified ); */;
//
Int32 updatedRows = await adapter.UpdateAsync(dataSetFromProxy); // updatedRows... in first table only?
// updatedRows.ShouldBe( rowsModified );
}
}
}
// Part 2: Use real
DataSet dataSetFromReal;
{
using (FakeDbConnection connection = new FakeDbConnection(asyncMode: AsyncMode.AllowSync))
using (FakeDbCommand selectCommand = connection.CreateCommand(testTables: randomDataSource))
{
connection.Open();
using (FakeDbDataAdapter adapter = new FakeDbDataAdapter(selectCommand))
using (FakeDbCommandBuilder cmdBuilder = adapter.CreateCommandBuilder())
{
dataSetFromReal = new DataSet();
// `.Fill` returns the number of rows in the first table, not any subsequent tables. Yes, that's silly.
Int32 rowsInFirstTable = adapter.Fill(dataSetFromReal);
rowsInFirstTable.ShouldBe(40);
//
Dictionary <String, Int32> rowsModified = DataTableMethods.MutateDataSet(dataSetFromReal);
//
adapter.UpdateCommand = cmdBuilder.GetUpdateCommand();
adapter.UpdateCommand.NonQueryResultRowCountValue = (cmd) => 1; // HACK /* DataTableMethods.GetNonQueryResultRowCountValue( dataSetFromProxy, cmd, rowsModified ); */;
//
Int32 updatedRows = adapter.Update(dataSetFromReal); // updatedRows... in first table only?
// updatedRows.ShouldBe( rowsModified );
}
}
}
// Assert equality:
DataTableMethods.DataSetEquals(dataSetFromProxy, dataSetFromReal, out String diffs).ShouldBeTrue(customMessage: diffs);
}
public void Proxy_Update_should_work_identically_to_Update()
{
List <TestTable> randomDataSource = RandomDataGenerator.CreateRandomTables(seed: 1234, tableCount: 5, /*allowZeroRowsInTablesByIdx: */ 1, 3);
// TODO: Multiple table UPDATE support is... complicated: https://stackoverflow.com/questions/16218856/how-to-update-two-tables-with-one-dataset
// Part 1: Use proxy
DataSet dataSetFromProxy;
{
using (FakeDbConnection connection = new FakeDbConnection(asyncMode: AsyncMode.AllowSync))
using (FakeDbCommand selectCommand = connection.CreateCommand(testTables: randomDataSource))
{
connection.Open();
using (BatchingFakeProxiedDbDataAdapter adapter = new BatchingFakeProxiedDbDataAdapter(selectCommand))
using (FakeDbCommandBuilder cmdBuilder = new FakeDbCommandBuilder(adapter))
{
dataSetFromProxy = new DataSet();
// `.Fill` returns the number of rows in the first table, not any subsequent tables. Yes, that's silly.
Int32 rowsInFirstTable = adapter.Fill(dataSetFromProxy);
rowsInFirstTable.ShouldBe(40);
//
Dictionary <String, Int32> rowsModified = DataTableMethods.MutateDataSet(dataSetFromProxy);
//
adapter.UpdateCommand = cmdBuilder.GetUpdateCommand();
adapter.UpdateCommand.NonQueryResultRowCountValue = (cmd) => DataTableMethods.GetUpdateStatementNonQueryResultRowCountValue(expectedTableName: "TODO", adapter, dataSetFromProxy, cmd, rowsModified);
Int32 updatedRows = adapter.Update(dataSetFromProxy); // updatedRows... in first table only?
// updatedRows.ShouldBe( rowsModified );
}
}
}
// Part 2: Use real
DataSet dataSetFromReal;
{
using (FakeDbConnection connection = new FakeDbConnection(asyncMode: AsyncMode.AllowSync))
using (FakeDbCommand selectCommand = connection.CreateCommand(testTables: randomDataSource))
{
connection.Open();
using (FakeDbDataAdapter adapter = new FakeDbDataAdapter(selectCommand))
using (FakeDbCommandBuilder cmdBuilder = adapter.CreateCommandBuilder())
{
dataSetFromReal = new DataSet();
// `.Fill` returns the number of rows in the first table, not any subsequent tables. Yes, that's silly.
Int32 rowsInFirstTable = adapter.Fill(dataSetFromReal);
rowsInFirstTable.ShouldBe(40);
//
Dictionary <String, Int32> rowsModified = DataTableMethods.MutateDataSet(dataSetFromReal);
//
adapter.UpdateCommand = cmdBuilder.GetUpdateCommand();
adapter.UpdateCommand.NonQueryResultRowCountValue = (cmd) => DataTableMethods.GetUpdateStatementNonQueryResultRowCountValue(expectedTableName: "TODO", adapter, dataSetFromReal, cmd, rowsModified);
Int32 updatedRows = adapter.Update(dataSetFromReal); // updatedRows... in first table only?
// updatedRows.ShouldBe( rowsModified );
}
}
}
// Assert equality:
DataTableMethods.DataSetEquals(dataSetFromProxy, dataSetFromReal, out String diffs).ShouldBeTrue(customMessage: diffs);
}
public FakeDbTransaction(FakeDbConnection connection, IsolationLevel isolationLevel = IsolationLevel.Unspecified)
{
DbConnection = connection;
IsolationLevel = isolationLevel;
}
