public FakeDbCommand( FakeDbConnection connection, FakeCommandExecutor commandExecutor) { DbConnection = connection; _commandExecutor = commandExecutor; }
protected override DbConnection CreateDbConnection() { var connection = new FakeDbConnection(ConnectionString); _dbConnections.Add(connection); return connection; }
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>>()), false); Assert.Equal(dbTransaction, transaction.GetDbTransaction()); }
public void Existing_connection_is_not_disposed_even_after_being_opened_and_closed() { var dbConnection = new FakeDbConnection("Database=FrodoLives"); var connection = new FakeRelationalConnection( CreateOptions(new FakeRelationalOptionsExtension { Connection = dbConnection })); Assert.Equal(0, connection.DbConnections.Count); Assert.Same(dbConnection, connection.DbConnection); connection.Open(); connection.Close(); connection.Dispose(); Assert.Equal(1, dbConnection.OpenCount); Assert.Equal(1, dbConnection.CloseCount); Assert.Equal(0, dbConnection.DisposeCount); Assert.Equal(0, connection.DbConnections.Count); Assert.Same(dbConnection, connection.DbConnection); connection.Open(); connection.Close(); connection.Dispose(); Assert.Equal(2, dbConnection.OpenCount); Assert.Equal(2, dbConnection.CloseCount); Assert.Equal(0, dbConnection.DisposeCount); }
public void Existing_connection_can_be_opened_and_closed_externally() { 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); 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); } }
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 { Connection = 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 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 Can_create_new_connection_from_exsting_DbConnection() { var dbConnection = new FakeDbConnection("Database=FrodoLives"); using (var connection = new FakeRelationalConnection( CreateOptions(new FakeRelationalOptionsExtension { Connection = dbConnection }))) { Assert.Equal(0, connection.DbConnections.Count); Assert.Same(dbConnection, connection.DbConnection); Assert.Equal(0, connection.DbConnections.Count); } }
public FakeDbTransaction(FakeDbConnection connection, IsolationLevel isolationLevel = IsolationLevel.Unspecified) { DbConnection = connection; IsolationLevel = isolationLevel; }
public async Task Can_ExecuteReaderAsync(bool manageConnection) { var executeReaderCount = 0; var disposeCount = -1; var dbDataReader = new FakeDbDataReader(); var fakeDbConnection = new FakeDbConnection( ConnectionString, new FakeCommandExecutor( executeReaderAsync: (c, b, ct) => { executeReaderCount++; disposeCount = c.DisposeCount; return Task.FromResult<DbDataReader>(dbDataReader); })); var optionsExtension = new FakeRelationalOptionsExtension { Connection = fakeDbConnection }; var options = CreateOptions(optionsExtension); var relationalCommand = CreateRelationalCommand(); var result = await relationalCommand.ExecuteReaderAsync( new FakeRelationalConnection(options), manageConnection: manageConnection); Assert.Same(dbDataReader, result.DbDataReader); Assert.Equal(0, fakeDbConnection.CloseCount); var expectedCount = manageConnection ? 1 : 0; Assert.Equal(expectedCount, fakeDbConnection.OpenCount); // Durring command execution Assert.Equal(1, executeReaderCount); Assert.Equal(0, disposeCount); // After command execution Assert.Equal(0, dbDataReader.DisposeCount); Assert.Equal(0, fakeDbConnection.DbCommands[0].DisposeCount); // After reader dispose result.Dispose(); Assert.Equal(1, dbDataReader.DisposeCount); Assert.Equal(1, fakeDbConnection.DbCommands[0].DisposeCount); Assert.Equal(expectedCount, fakeDbConnection.CloseCount); }
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 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, true)); } else { Assert.Throws<InvalidOperationException>(() => ((CommandAction)commandDelegate)(fakeConnection, relationalCommand, parameterValues, true)); } 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 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 FakeDbTransaction(FakeDbConnection connection, IsolationLevel isolationLevel = IsolationLevel.Unspecified) { DbConnection = connection; IsolationLevel = isolationLevel; }
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 { Connection = dbConnection }))) { using (connection.UseTransaction(dbTransaction)) { Assert.Equal(dbTransaction, connection.CurrentTransaction.GetDbTransaction()); } } }
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 { 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, false)); Assert.Equal(0, fakeDbConnection.OpenAsyncCount); } else { Assert.Throws<InvalidOperationException>(() => ((CommandAction)commandDelegate)(fakeConnection, relationalCommand, null, false)); Assert.Equal(0, fakeDbConnection.OpenCount); } Assert.Equal(0, fakeDbConnection.CloseCount); }
private static FakeRelationalConnection CreateConnection(DbDataReader dbDataReader) { var fakeDbConnection = new FakeDbConnection( ConnectionString, new FakeCommandExecutor( executeReaderAsync: (c, b, ct) => Task.FromResult(dbDataReader), executeReader: (c, b) => dbDataReader)); var optionsExtension = new FakeRelationalOptionsExtension { Connection = fakeDbConnection }; var options = CreateOptions(optionsExtension); return CreateConnection(options); }
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 { Connection = 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); }