public async Task Reports_command_diagnostic( Delegate commandDelegate, DbCommandMethod diagnosticName, bool async) { var options = CreateOptions(); var fakeConnection = new FakeRelationalConnection(options); var diagnostic = new List <Tuple <string, object> >(); var relationalCommand = CreateRelationalCommand( new DiagnosticsLogger <DbLoggerCategory.Database.Command>( new ListLoggerFactory(new List <(LogLevel, EventId, string)>()), new FakeLoggingOptions(false), new ListDiagnosticSource(diagnostic)), parameters: new[] { new TypeMappedRelationalParameter("FirstInvariant", "FirstParameter", new IntTypeMapping("int", DbType.Int32), false) }); var parameterValues = new Dictionary <string, object> { { "FirstInvariant", 17 } }; if (async) { await((CommandFunc)commandDelegate)(fakeConnection, relationalCommand, parameterValues); } else { ((CommandAction)commandDelegate)(fakeConnection, relationalCommand, parameterValues); } Assert.Equal(2, diagnostic.Count); Assert.Equal(RelationalEventId.CommandExecuting.Name, diagnostic[0].Item1); Assert.Equal(RelationalEventId.CommandExecuted.Name, diagnostic[1].Item1); var beforeData = (CommandEventData)diagnostic[0].Item2; var afterData = (CommandExecutedEventData)diagnostic[1].Item2; Assert.Equal(fakeConnection.DbConnections[0].DbCommands[0], beforeData.Command); Assert.Equal(fakeConnection.DbConnections[0].DbCommands[0], afterData.Command); Assert.Equal(diagnosticName, beforeData.ExecuteMethod); Assert.Equal(diagnosticName, afterData.ExecuteMethod); Assert.Equal(async, beforeData.IsAsync); Assert.Equal(async, afterData.IsAsync); }
public async Task Logs_commands_parameter_values( Delegate commandDelegate, string diagnosticName, bool async) { var optionsExtension = new FakeRelationalOptionsExtension().WithConnectionString(ConnectionString); var options = CreateOptions(optionsExtension); var logFactory = new ListLoggerFactory(); var fakeConnection = new FakeRelationalConnection(options); var relationalCommand = CreateRelationalCommand( new DiagnosticsLogger <DbLoggerCategory.Database.Command>( logFactory, new FakeLoggingOptions(true), new DiagnosticListener("Fake")), commandText: "Logged Command", parameters: new[] { new TypeMappedRelationalParameter("FirstInvariant", "FirstParameter", new IntTypeMapping("int", DbType.Int32), false) }); var parameterValues = new Dictionary <string, object> { { "FirstInvariant", 17 } }; if (async) { await((CommandFunc)commandDelegate)(fakeConnection, relationalCommand, parameterValues); } else { ((CommandAction)commandDelegate)(fakeConnection, relationalCommand, parameterValues); } Assert.Equal(3, logFactory.Log.Count); Assert.Equal(LogLevel.Warning, logFactory.Log[0].Level); Assert.Equal(CoreStrings.LogSensitiveDataLoggingEnabled.GenerateMessage(), logFactory.Log[0].Message); Assert.Equal(LogLevel.Debug, logFactory.Log[1].Level); Assert.Equal(LogLevel.Information, logFactory.Log[2].Level); foreach (var(_, _, message, _, _) in logFactory.Log.Skip(1)) { Assert.EndsWith( "[Parameters=[FirstParameter='17'], CommandType='0', CommandTimeout='30']" + _eol + "Logged Command", message); } }
public async Task Logs_commands_without_parameter_values( Delegate commandDelegate, string diagnosticName, bool async) { var options = CreateOptions(); var logFactory = new ListLoggerFactory(); var fakeConnection = new FakeRelationalConnection(options); var logger = new DiagnosticsLogger <DbLoggerCategory.Database.Command>( logFactory, new FakeLoggingOptions(false), new DiagnosticListener("Fake"), new RelationalLoggingDefinitions()); var relationalCommand = CreateRelationalCommand( commandText: "Logged Command", parameters: new[] { new TypeMappedRelationalParameter("FirstInvariant", "FirstParameter", new IntTypeMapping("int", DbType.Int32), false) }); var parameterValues = new Dictionary <string, object> { { "FirstInvariant", 17 } }; if (async) { await((CommandFunc)commandDelegate)(fakeConnection, relationalCommand, parameterValues, logger); } else { ((CommandAction)commandDelegate)(fakeConnection, relationalCommand, parameterValues, logger); } Assert.Equal(2, logFactory.Log.Count); Assert.Equal(LogLevel.Debug, logFactory.Log[0].Level); Assert.Equal(LogLevel.Debug, logFactory.Log[1].Level); foreach (var(_, _, message, _, _) in logFactory.Log) { Assert.EndsWith( "[Parameters=[FirstParameter='?' (DbType = Int32)], CommandType='0', CommandTimeout='30']" + _eol + "Logged Command", message); } }
public void Can_create_new_connection_from_exsting_DbConnection() { var dbConnection = new FakeDbConnection("Database=FrodoLives"); using (var connection = new FakeRelationalConnection( CreateOptions(new FakeRelationalOptionsExtension().WithConnection(dbConnection)))) { Assert.Equal(0, connection.DbConnections.Count); Assert.Same(dbConnection, connection.DbConnection); Assert.Equal(0, connection.DbConnections.Count); } }
public async Task Logs_commands_parameter_values( Delegate commandDelegate, string diagnosticName, bool async) { var optionsExtension = new FakeRelationalOptionsExtension { ConnectionString = ConnectionString }; var options = CreateOptions(optionsExtension, logParameters: true); var log = new List <Tuple <LogLevel, string> >(); var fakeConnection = new FakeRelationalConnection(options); var relationalCommand = CreateRelationalCommand( logger: new SensitiveDataLogger <RelationalCommand>( new SensitiveDataLoggerDependencies <RelationalCommand>( new ListLogger <RelationalCommand>(log), options)), commandText: "Logged Command", 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((CommandFunc)commandDelegate)(fakeConnection, relationalCommand, parameterValues); } else { ((CommandAction)commandDelegate)(fakeConnection, relationalCommand, parameterValues); } Assert.Equal(2, log.Count); Assert.Equal(LogLevel.Warning, log[0].Item1); Assert.Equal(CoreStrings.SensitiveDataLoggingEnabled, log[0].Item2); Assert.Equal(LogLevel.Information, log[1].Item1); Assert.EndsWith( @"ms) [Parameters=[FirstParameter='17'], CommandType='0', CommandTimeout='30'] Logged Command", log[1].Item2.Replace(Environment.NewLine, FileLineEnding)); }
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 = new RelationalCommand( new FakeSensitiveDataLogger <RelationalCommand>(), new DiagnosticListener("Fake"), "ExecuteReader Command", new RelationalParameter[0]); if (async) { await Assert.ThrowsAsync <InvalidOperationException>( async() => await((Func <RelationalCommand, bool, IRelationalConnection, Task>)commandDelegate)(relationalCommand, false, fakeConnection)); Assert.Equal(0, fakeDbConnection.OpenAsyncCount); } else { Assert.Throws <InvalidOperationException>(() => ((Action <RelationalCommand, bool, IRelationalConnection>)commandDelegate)(relationalCommand, false, fakeConnection)); Assert.Equal(0, fakeDbConnection.OpenCount); } Assert.Equal(0, fakeDbConnection.CloseCount); }
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 async Task Logs_commands_without_parameter_values( Delegate commandDelegate, string diagnosticName, bool async) { var options = CreateOptions(); var log = new List <Tuple <LogLevel, EventId, string> >(); var fakeConnection = new FakeRelationalConnection(options); var relationalCommand = CreateRelationalCommand( new DiagnosticsLogger <DbLoggerCategory.Database.Command>( new ListLoggerFactory(log), new FakeLoggingOptions(false), new DiagnosticListener("Fake")), commandText: "Logged Command", parameters: new[] { new TypeMappedRelationalParameter("FirstInvariant", "FirstParameter", new IntTypeMapping("int", DbType.Int32), false) }); var parameterValues = new Dictionary <string, object> { { "FirstInvariant", 17 } }; if (async) { await((CommandFunc)commandDelegate)(fakeConnection, relationalCommand, parameterValues); } else { ((CommandAction)commandDelegate)(fakeConnection, relationalCommand, parameterValues); } Assert.Equal(2, log.Count); Assert.Equal(LogLevel.Debug, log[0].Item1); Assert.Equal(LogLevel.Information, log[1].Item1); foreach (var item in log) { Assert.EndsWith( @"[Parameters=[FirstParameter='?'], CommandType='0', CommandTimeout='30'] Logged Command", item.Item3.Replace(Environment.NewLine, FileLineEnding)); } }
public void Can_create_new_connection_lazily_using_given_connection_string() { using (var connection = new FakeRelationalConnection( CreateOptions(new FakeRelationalOptionsExtension { ConnectionString = "Database=FrodoLives" }))) { Assert.Equal(0, connection.DbConnections.Count); var dbConnection = connection.DbConnection; Assert.Equal(1, connection.DbConnections.Count); Assert.Equal("Database=FrodoLives", dbConnection.ConnectionString); } }
public void Throws_when_rollback_is_called_without_active_transaction() { using (var connection = new FakeRelationalConnection( CreateOptions(new FakeRelationalOptionsExtension { ConnectionString = "Database=FrodoLives" }))) { Assert.Equal(0, connection.DbConnections.Count); Assert.Equal( RelationalStrings.NoActiveTransaction, Assert.Throws <InvalidOperationException>( () => connection.RollbackTransaction()).Message); } }
public async Task Reports_command_diagnostic( Delegate commandDelegate, string diagnosticName, bool async) { var options = CreateOptions(); var fakeConnection = new FakeRelationalConnection(options); var diagnostic = new List <Tuple <string, object> >(); 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((CommandFunc)commandDelegate)(fakeConnection, relationalCommand, parameterValues); } else { ((CommandAction)commandDelegate)(fakeConnection, relationalCommand, parameterValues); } Assert.Equal(2, diagnostic.Count); Assert.Equal(RelationalDiagnostics.BeforeExecuteCommand, diagnostic[0].Item1); Assert.Equal(RelationalDiagnostics.AfterExecuteCommand, diagnostic[1].Item1); var beforeData = (RelationalDiagnosticSourceBeforeMessage)diagnostic[0].Item2; var afterData = (RelationalDiagnosticSourceAfterMessage)diagnostic[1].Item2; Assert.Equal(fakeConnection.DbConnections[0].DbCommands[0], beforeData.Command); Assert.Equal(fakeConnection.DbConnections[0].DbCommands[0], afterData.Command); Assert.Equal(diagnosticName, beforeData.ExecuteMethod); Assert.Equal(diagnosticName, afterData.ExecuteMethod); Assert.Equal(async, beforeData.IsAsync); Assert.Equal(async, afterData.IsAsync); }
public async Task Logs_commands_parameter_values_and_warnings( Delegate commandDelegate, string diagnosticName, bool async) { var optionsExtension = new FakeRelationalOptionsExtension { ConnectionString = ConnectionString }; var options = CreateOptions(optionsExtension, logParameters: true); var fakeConnection = new FakeRelationalConnection(options); var log = new List <Tuple <LogLevel, string> >(); var relationalCommand = new RelationalCommand( new SensitiveDataLogger <RelationalCommand>( new ListLogger <RelationalCommand>(log), options), new DiagnosticListener("Fake"), "Command Text", new[] { new RelationalParameter("FirstParameter", 17, new RelationalTypeMapping("int", typeof(int), DbType.Int32), false) }); if (async) { await((Func <RelationalCommand, bool, IRelationalConnection, Task>)commandDelegate)(relationalCommand, true, fakeConnection); } else { ((Action <RelationalCommand, bool, IRelationalConnection>)commandDelegate)(relationalCommand, true, fakeConnection); } Assert.Equal(2, log.Count); Assert.Equal(LogLevel.Warning, log[0].Item1); Assert.Equal( @"SQL parameter value logging is enabled. As SQL parameter values may include sensitive application data, this mode should only be enabled during development.", log[0].Item2); Assert.Equal(LogLevel.Information, log[1].Item1); Assert.EndsWith( @"[Parameters=[FirstParameter='17'], CommandType='0', CommandTimeout='30'] Command Text", log[1].Item2); }
public async Task Reports_command_diagnostic( Delegate commandDelegate, string diagnosticName, bool async) { var options = CreateOptions(); 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((Func <RelationalCommand, bool, IRelationalConnection, Task>)commandDelegate)(relationalCommand, true, fakeConnection); } else { ((Action <RelationalCommand, bool, IRelationalConnection>)commandDelegate)(relationalCommand, true, fakeConnection); } Assert.Equal(2, diagnostic.Count); Assert.Equal(RelationalDiagnostics.BeforeExecuteCommand, diagnostic[0].Item1); Assert.Equal(RelationalDiagnostics.AfterExecuteCommand, diagnostic[1].Item1); var beforeData = (RelationalDiagnosticSourceMessage)diagnostic[0].Item2; var afterData = (RelationalDiagnosticSourceMessage)diagnostic[1].Item2; Assert.Equal(fakeConnection.DbConnections[0].DbCommands[0], beforeData.Command); Assert.Equal(fakeConnection.DbConnections[0].DbCommands[0], afterData.Command); Assert.Equal(diagnosticName, beforeData.ExecuteMethod); Assert.Equal(diagnosticName, afterData.ExecuteMethod); Assert.Equal(async, beforeData.IsAsync); Assert.Equal(async, afterData.IsAsync); }
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 transaction = new RelationalTransaction( connection, dbTransaction, new InterceptingLogger <LoggerCategory.Database.Transaction>(new ListLoggerFactory(new List <Tuple <LogLevel, string> >()), new LoggingOptions()), new DiagnosticListener("Fake"), false); Assert.Equal(dbTransaction, transaction.GetDbTransaction()); }
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 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 fakeConnection = new FakeRelationalConnection(options); var relationalCommand = new RelationalCommand( new FakeSensitiveDataLogger <RelationalCommand>(), new DiagnosticListener("Fake"), "ExecuteNonQuery Command", new RelationalParameter[0]); var result = relationalCommand.ExecuteNonQuery(fakeConnection, 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 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 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 fakeConnection = new FakeRelationalConnection(options); var relationalCommand = new RelationalCommand( new FakeSensitiveDataLogger <RelationalCommand>(), new DiagnosticListener("Fake"), "ExecuteScalar Command", new RelationalParameter[0]); var result = (string)await relationalCommand.ExecuteScalarAsync(fakeConnection, 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 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)); 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 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 async Task Lazy_connection_is_async_opened_and_closed_when_necessary() { using (var connection = new FakeRelationalConnection( CreateOptions(new FakeRelationalOptionsExtension { ConnectionString = "Database=FrodoLives" }))) { Assert.Equal(0, connection.DbConnections.Count); var cancellationToken = new CancellationTokenSource().Token; await connection.OpenAsync(cancellationToken); Assert.Equal(1, connection.DbConnections.Count); var dbConnection = connection.DbConnections[0]; Assert.Equal(1, dbConnection.OpenAsyncCount); await connection.OpenAsync(cancellationToken); await connection.OpenAsync(cancellationToken); Assert.Equal(1, dbConnection.OpenAsyncCount); connection.Close(); connection.Close(); Assert.Equal(1, dbConnection.OpenAsyncCount); Assert.Equal(0, dbConnection.CloseCount); connection.Close(); Assert.Equal(1, dbConnection.OpenAsyncCount); Assert.Equal(1, dbConnection.CloseCount); await connection.OpenAsync(cancellationToken); Assert.Equal(2, dbConnection.OpenAsyncCount); connection.Close(); Assert.Equal(2, dbConnection.OpenAsyncCount); Assert.Equal(2, 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 async Task Logs_commands_without_parameter_values( Delegate commandDelegate, string diagnosticName, bool async) { var options = CreateOptions(); var log = new List <Tuple <LogLevel, string> >(); var fakeConnection = new FakeRelationalConnection(options); var relationalCommand = CreateRelationalCommand( logger: new SensitiveDataLogger <RelationalCommand>( new ListLogger <RelationalCommand>(log), options), commandText: "Logged Command", 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((CommandFunc)commandDelegate)(fakeConnection, relationalCommand, parameterValues, true); } else { ((CommandAction)commandDelegate)(fakeConnection, relationalCommand, parameterValues, true); } Assert.Equal(1, log.Count); Assert.Equal(LogLevel.Information, log[0].Item1); Assert.EndsWith( @"[Parameters=[FirstParameter='?'], CommandType='0', CommandTimeout='30'] Logged Command", log[0].Item2); }
public void Lazy_connection_is_opened_and_closed_when_necessary() { using (var connection = new FakeRelationalConnection( CreateOptions(new FakeRelationalOptionsExtension { ConnectionString = "Database=FrodoLives" }))) { Assert.Equal(0, connection.DbConnections.Count); connection.Open(); Assert.Equal(1, connection.DbConnections.Count); var dbConnection = connection.DbConnections[0]; 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 Lazy_connection_is_recreated_if_used_again_after_being_disposed() { var connection = new FakeRelationalConnection( CreateOptions(new FakeRelationalOptionsExtension { ConnectionString = "Database=FrodoLives" })); Assert.Equal(0, connection.DbConnections.Count); var dbConnection = (FakeDbConnection)connection.DbConnection; Assert.Equal(1, connection.DbConnections.Count); connection.Open(); #if DNX451 // On CoreCLR, DbConnection.Dispose() calls DbConnection.Close() connection.Close(); #endif connection.Dispose(); Assert.Equal(1, dbConnection.OpenCount); Assert.Equal(1, dbConnection.CloseCount); Assert.Equal(1, dbConnection.DisposeCount); Assert.Equal(1, connection.DbConnections.Count); dbConnection = (FakeDbConnection)connection.DbConnection; Assert.Equal(2, connection.DbConnections.Count); connection.Open(); #if DNX451 connection.Close(); #endif connection.Dispose(); Assert.Equal(1, dbConnection.OpenCount); Assert.Equal(1, dbConnection.CloseCount); Assert.Equal(1, dbConnection.DisposeCount); }
public async Task Transaction_can_begin_with_isolation_level_async() { using (var connection = new FakeRelationalConnection( CreateOptions(new FakeRelationalOptionsExtension { ConnectionString = "Database=FrodoLives" }))) { Assert.Equal(0, connection.DbConnections.Count); using (var transaction = await connection.BeginTransactionAsync(IsolationLevel.Chaos)) { Assert.Equal(1, connection.DbConnections.Count); var dbConnection = connection.DbConnections[0]; Assert.Equal(1, dbConnection.DbTransactions.Count); var dbTransaction = dbConnection.DbTransactions[0]; Assert.Equal(IsolationLevel.Chaos, dbTransaction.IsolationLevel); } } }
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().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)); } else { Assert.Throws <InvalidOperationException>( () => ((CommandAction)commandDelegate)(fakeConnection, relationalCommand, null)); } 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"), new TestRelationalLoggingDefinitions()), false); Assert.Equal(dbTransaction, transaction.GetDbTransaction()); }
public async Task Logs_commands_without_parameter_values( Delegate commandDelegate, string diagnosticName, bool async) { var options = CreateOptions(); var fakeConnection = new FakeRelationalConnection(options); var log = new List <Tuple <LogLevel, string> >(); var relationalCommand = new RelationalCommand( new SensitiveDataLogger <RelationalCommand>( new ListLogger <RelationalCommand>(log), options), new DiagnosticListener("Fake"), "Command Text", new[] { new RelationalParameter("FirstParameter", 17, new RelationalTypeMapping("int", typeof(int), DbType.Int32), false, null) }); if (async) { await((Func <RelationalCommand, bool, IRelationalConnection, Task>)commandDelegate)(relationalCommand, true, fakeConnection); } else { ((Action <RelationalCommand, bool, IRelationalConnection>)commandDelegate)(relationalCommand, true, fakeConnection); } Assert.Equal(1, log.Count); Assert.Equal(LogLevel.Information, log[0].Item1); Assert.EndsWith( @"[Parameters=[FirstParameter='?'], CommandType='0', CommandTimeout='30'] Command Text", log[0].Item2); }
public void Rollback_calls_rollback_on_DbTransaction() { using (var connection = new FakeRelationalConnection( CreateOptions(new FakeRelationalOptionsExtension { ConnectionString = "Database=FrodoLives" }))) { Assert.Equal(0, connection.DbConnections.Count); using (var transaction = connection.BeginTransaction()) { Assert.Equal(1, connection.DbConnections.Count); var dbConnection = connection.DbConnections[0]; Assert.Equal(1, dbConnection.DbTransactions.Count); var dbTransaction = dbConnection.DbTransactions[0]; connection.RollbackTransaction(); Assert.Equal(1, dbTransaction.RollbackCount); } } }