public static IDbContextOptions CreateOptions(
FakeRelationalOptionsExtension optionsExtension = null)
{
var optionsBuilder = new DbContextOptionsBuilder();
((IDbContextOptionsBuilderInfrastructure)optionsBuilder)
.AddOrUpdateExtension(optionsExtension ?? new FakeRelationalOptionsExtension { ConnectionString = ConnectionString });
return optionsBuilder.Options;
}
public void Configures_DbCommand_with_timeout()
{
var optionsExtension = new FakeRelationalOptionsExtension
{
ConnectionString = ConnectionString,
CommandTimeout = 42
};
var fakeConnection = CreateConnection(CreateOptions(optionsExtension));
var relationalCommand = CreateRelationalCommand();
relationalCommand.ExecuteNonQuery(fakeConnection);
Assert.Equal(1, fakeConnection.DbConnections.Count);
Assert.Equal(1, fakeConnection.DbConnections[0].DbCommands.Count);
var command = fakeConnection.DbConnections[0].DbCommands[0];
Assert.Equal(42, command.CommandTimeout);
}
public FakeRelationalOptionsExtension(FakeRelationalOptionsExtension copyFrom)
: base(copyFrom)
{
}
protected FakeRelationalOptionsExtension(FakeRelationalOptionsExtension copyFrom)
: base(copyFrom)
{
}
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 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 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(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);
}
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);
}
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);
}
private static IDbContextOptions CreateOptions(
FakeRelationalOptionsExtension optionsExtension = null, bool logParameters = false)
{
var optionsBuilder = new DbContextOptionsBuilder();
if (logParameters)
{
optionsBuilder.EnableSensitiveDataLogging();
}
((IDbContextOptionsBuilderInfrastructure)optionsBuilder)
.AddOrUpdateExtension(optionsExtension ?? new FakeRelationalOptionsExtension { ConnectionString = ConnectionString });
return optionsBuilder.Options;
}
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 FakeRelationalOptionsExtension(FakeRelationalOptionsExtension copyFrom)
: base(copyFrom)
{
}
