public void ExecuteReader_SimpleCommand_ResultOk_LoggedAsDebug()
{
var logSpy = new StringLogger();
using var connection = new SqliteConnection(connectionString);
connection.Open();
var queryCommand = connection.CreateCommand();
queryCommand.CommandText = @"
SELECT 1
UNION
SELECT 2";
// act
var loggedCmd = new LoggedDbCommand(queryCommand, logSpy);
using var reader = loggedCmd.ExecuteReader();
Assert.True(reader.Read());
Assert.Equal(1, reader.GetInt64(0));
Assert.True(reader.Read());
Assert.Equal(2, reader.GetInt64(0));
Assert.False(reader.Read());
Assert.Contains(queryCommand.CommandText, logSpy.Logs[LogLevel.Debug]);
}
public void ExecuteScalar_CommandWithParameter_ResultOk_LoggedAsDebug()
{
var logSpy = new StringLogger();
using var connection = new SqliteConnection(connectionString);
connection.Open();
var queryCommand = connection.CreateCommand();
queryCommand.CommandText = "SELECT @myparameter";
var param = queryCommand.CreateParameter();
param.SqliteType = SqliteType.Text;
param.ParameterName = "@myparameter";
param.Value = "SomeText";
queryCommand.Parameters.Add(param);
// act
var loggedCmd = new LoggedDbCommand(queryCommand, logSpy);
var result = (string)loggedCmd.ExecuteScalar();
var debugLogs = logSpy.Logs[LogLevel.Debug];
Assert.Equal("SomeText", result);
Assert.Contains(queryCommand.CommandText, debugLogs);
Assert.Contains("myparameter", debugLogs);
Assert.Contains("SomeText", debugLogs);
}
public void Ensure_Passthrough_Properties()
{
var innerCommand = new SqliteCommand();
var loggedCmd = new LoggedDbCommand(innerCommand, new StringLogger());
loggedCmd.CommandText = "abc";
Assert.Equal(loggedCmd.CommandText, innerCommand.CommandText);
loggedCmd.CommandTimeout = 75;
Assert.Equal(loggedCmd.CommandTimeout, innerCommand.CommandTimeout);
loggedCmd.CommandType = CommandType.Text;
Assert.Equal(loggedCmd.CommandType, innerCommand.CommandType);
loggedCmd.UpdatedRowSource = UpdateRowSource.OutputParameters;
Assert.Equal(loggedCmd.UpdatedRowSource, innerCommand.UpdatedRowSource);
loggedCmd.DesignTimeVisible = !loggedCmd.DesignTimeVisible;
Assert.Equal(loggedCmd.DesignTimeVisible, innerCommand.DesignTimeVisible);
Assert.Equal(loggedCmd.Parameters, innerCommand.Parameters);
using var cnx = new SqliteConnection(connectionString);
cnx.Open();
loggedCmd.Transaction = cnx.BeginTransaction();
Assert.Equal(loggedCmd.Transaction, innerCommand.Transaction);
}
public void ExecuteScalar_SyntaxError_LoggedAsError()
{
var logSpy = new StringLogger();
using var connection = new SqliteConnection(connectionString);
connection.Open();
var queryCommand = connection.CreateCommand();
queryCommand.CommandText = "SELEC_error 1";
// act
var loggedCmd = new LoggedDbCommand(queryCommand, logSpy);
try
{
var result = (long)loggedCmd.ExecuteScalar();
}
catch (Exception ex)
{
Assert.Contains("syntax error", ex.Message);
}
Assert.Contains(queryCommand.CommandText, logSpy.Logs[LogLevel.Debug]);
Assert.Contains(queryCommand.CommandText, logSpy.Logs[LogLevel.Error]);
}
public void Ensure_Passthrough_Properties_And_Methods_Called()
{
var logger = new Mock <ILogger>();
var dbCmdSpy = new Mock <DbCommand>()
{
CallBase = true, DefaultValue = DefaultValue.Mock
};
dbCmdSpy.SetupAllProperties();
var loggedCmd = new LoggedDbCommand(dbCmdSpy.Object, logger.Object);
loggedCmd.Cancel();
dbCmdSpy.Verify(p => p.Cancel(), Times.Once);
loggedCmd.Prepare();
dbCmdSpy.Verify(p => p.Prepare(), Times.Once);
loggedCmd.ExecuteNonQuery();
dbCmdSpy.Verify(p => p.ExecuteNonQuery(), Times.Once);
loggedCmd.ExecuteScalar();
dbCmdSpy.Verify(p => p.ExecuteScalar(), Times.Once);
loggedCmd.CommandText = "abc";
dbCmdSpy.VerifySet(p => p.CommandText = "abc", Times.Once);
Assert.Equal("abc", loggedCmd.CommandText);
loggedCmd.CommandTimeout = 75;
dbCmdSpy.VerifySet(p => p.CommandTimeout = 75, Times.Once);
Assert.Equal(75, loggedCmd.CommandTimeout);
loggedCmd.CommandType = CommandType.TableDirect;
dbCmdSpy.VerifySet(p => p.CommandType = CommandType.TableDirect, Times.Once);
Assert.Equal(CommandType.TableDirect, loggedCmd.CommandType);
loggedCmd.UpdatedRowSource = UpdateRowSource.OutputParameters;
dbCmdSpy.VerifySet(p => p.UpdatedRowSource = UpdateRowSource.OutputParameters, Times.Once);
Assert.Equal(UpdateRowSource.OutputParameters, loggedCmd.UpdatedRowSource);
loggedCmd.DesignTimeVisible = true;
dbCmdSpy.VerifySet(p => p.DesignTimeVisible = true, Times.Once);
Assert.True(loggedCmd.DesignTimeVisible);
var protectedMock = dbCmdSpy.Protected().As <DbCommandProtectedMembers>();
var expectedDbParam = new Mock <DbParameter>().Object;
protectedMock.Setup(p => p.CreateDbParameter()).Returns(expectedDbParam);
var resultedDbParam = loggedCmd.CreateParameter();
Assert.Equal(expectedDbParam, resultedDbParam);
protectedMock.Verify(p => p.CreateDbParameter(), Times.Once());
}
public void ExecuteNonQuery_SimpleCommand_ResultOk_LoggedAsDebug()
{
var logSpy = new StringLogger();
using var connection = new SqliteConnection(connectionString);
connection.Open();
var queryCommand = connection.CreateCommand();
queryCommand.CommandText = "DROP TABLE IF EXISTS People";
// act
var loggedCmd = new LoggedDbCommand(queryCommand, logSpy);
loggedCmd.ExecuteNonQuery();
Assert.Contains(queryCommand.CommandText, logSpy.Logs[LogLevel.Debug]);
}
public void ExecuteScalar_SimpleCommand_ResultOk_LoggedAsDebug()
{
var logSpy = new StringLogger();
using var connection = new SqliteConnection(connectionString);
connection.Open();
var queryCommand = connection.CreateCommand();
queryCommand.CommandText = "SELECT 1";
// act
var loggedCmd = new LoggedDbCommand(queryCommand, logSpy);
var result = (long)loggedCmd.ExecuteScalar();
Assert.Equal(1, result);
Assert.Contains(queryCommand.CommandText, logSpy.Logs[LogLevel.Debug]);
}
