public void DataSource_returns_connection_string_filename_when_closed()
{
using (var connection = new SQLiteConnection("Filename=test.db"))
{
Assert.Equal("test.db", connection.DataSource);
}
}
public void ConnectionString_gets_and_sets_value()
{
using (var connection = new SQLiteConnection { ConnectionString = "Filename=test.db" })
{
Assert.Equal("Filename=test.db", connection.ConnectionString);
}
}
public void Ctor_sets_connection_string()
{
using (var connection = new SQLiteConnection("Filename=test.db"))
{
Assert.Equal("Filename=test.db", connection.ConnectionString);
}
}
public void Database_returns_value()
{
using (var connection = new SQLiteConnection())
{
Assert.Equal("main", connection.Database);
}
}
public override void Commit()
{
CheckCompleted();
_connection.ExecuteNonQuery("COMMIT");
_connection.Transaction = null;
_connection = null;
}
public SQLiteCommand([NotNull] string commandText, [NotNull] SQLiteConnection connection)
: this(commandText)
{
Check.NotEmpty(commandText, "commandText");
Check.NotNull(connection, "connection");
_connection = connection;
}
public void ConnectionString_setter_validates_argument()
{
using (var connection = new SQLiteConnection())
{
var ex = Assert.Throws<ArgumentException>(() => connection.ConnectionString = null);
Assert.Equal(Strings.FormatArgumentIsNullOrWhitespace("value"), ex.Message);
}
}
public void Ctor_throws_when_invalid_isolation_level()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
connection.Open();
var ex = Assert.Throws<ArgumentException>(() => connection.BeginTransaction(0));
Assert.Equal(Strings.FormatInvalidIsolationLevel(0), ex.Message);
}
}
public void DataSource_returns_actual_filename_when_open()
{
using (var connection = new SQLiteConnection("Filename=test.db"))
{
connection.Open();
var result = connection.DataSource;
Assert.True(Path.IsPathRooted(result));
Assert.Equal("test.db", Path.GetFileName(result));
}
}
public void Ctor_unsets_read_uncommitted_when_serializable()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
connection.Open();
using (connection.BeginTransaction(IsolationLevel.Serializable))
{
Assert.Equal(0L, connection.ExecuteScalar<long>("PRAGMA read_uncommitted"));
}
}
}
public void ConnectionString_setter_throws_when_open()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
connection.Open();
var ex = Assert.Throws<InvalidOperationException>(
() => connection.ConnectionString = "Filename=test.db");
Assert.Equal(Strings.ConnectionStringRequiresClosedConnection, ex.Message);
}
}
public void IsolationLevel_is_infered_when_unspecified()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
connection.Open();
connection.ExecuteNonQuery("PRAGMA read_uncommitted = 1");
using (var transaction = connection.BeginTransaction())
{
Assert.Equal(IsolationLevel.ReadUncommitted, transaction.IsolationLevel);
}
}
}
public void IsolationLevel_throws_when_completed()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
connection.Open();
var transaction = connection.BeginTransaction();
transaction.Dispose();
var ex = Assert.Throws<InvalidOperationException>(() => transaction.IsolationLevel);
Assert.Equal(Strings.TransactionCompleted, ex.Message);
}
}
public void Ctor_validates_arguments()
{
var ex = Assert.Throws<ArgumentException>(() => new SQLiteCommand(null));
Assert.Equal(Strings.FormatArgumentIsNullOrWhitespace("commandText"), ex.Message);
Assert.Throws<ArgumentNullException>("connection", () => new SQLiteCommand("SELECT 1", null));
using (var connection = new SQLiteConnection())
{
Assert.Throws<ArgumentNullException>(
"transaction",
() => new SQLiteCommand("SELECT 1", connection, null));
}
}
public void FieldCount_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT 1";
connection.Open();
using (var reader = command.ExecuteReader())
{
Assert.Equal(1, reader.FieldCount);
}
}
}
}
public void HasRows_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT 1";
connection.Open();
using (var reader = command.ExecuteReader())
{
Assert.True(reader.HasRows);
}
}
}
}
public void ParameterName_doesnt_unset_bound_when_unchanged()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT @Parameter";
var parameter = command.Parameters.AddWithValue("@Parameter", 1);
connection.Open();
command.ExecuteNonQuery();
parameter.ParameterName = "@Parameter";
Assert.True(parameter.Bound);
}
}
}
public void RecordsAffected_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
connection.Open();
CreateTestTable(connection);
command.CommandText = "INSERT INTO TestTable (Int32Column) VALUES (2)";
using (var reader = command.ExecuteReader())
{
Assert.Equal(1, reader.RecordsAffected);
}
}
}
}
public DbException GetConnectionError(string overrideConnectionInfo)
{
DbException exception = null;
SQLiteConnection connection;
if (
(overrideConnectionInfo != null)
&& (overrideConnectionInfo.Length > 0)
)
{
connection = new SQLiteConnection(overrideConnectionInfo);
}
else
{
connection = new SQLiteConnection(connectionString);
}
try
{
connection.Open();
}
catch (DbException ex)
{
exception = ex;
}
finally
{
if (connection.State == ConnectionState.Open)
connection.Close();
}
return exception;
}
private static void PrepareCommand(
SQLiteCommand command,
SQLiteConnection connection,
SQLiteTransaction transaction,
CommandType commandType,
string commandText,
DbParameter[] commandParameters)
{
if (command == null) throw new ArgumentNullException("command");
if (string.IsNullOrEmpty(commandText)) throw new ArgumentNullException("commandText");
command.CommandType = commandType;
command.CommandText = commandText;
command.Connection = connection;
if (transaction != null)
{
if (transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
command.Transaction = transaction;
}
if (commandParameters != null) { AttachParameters(command, commandParameters); }
}
internal SQLiteTransaction(SQLiteConnection connection, IsolationLevel isolationLevel)
{
Debug.Assert(connection != null, "connection is null.");
Debug.Assert(connection.State == ConnectionState.Open, "connection.State is not Open.");
_connection = connection;
_isolationLevel = isolationLevel;
if (_isolationLevel == IsolationLevel.ReadUncommitted)
{
_connection.ExecuteNonQuery("PRAGMA read_uncommitted = 1");
}
else if (_isolationLevel == IsolationLevel.Serializable)
{
_connection.ExecuteNonQuery("PRAGMA read_uncommitted = 0");
}
else if (_isolationLevel != IsolationLevel.Unspecified)
{
throw new ArgumentException(Strings.FormatInvalidIsolationLevel(isolationLevel));
}
_connection.ExecuteNonQuery("BEGIN");
}
private static void CreateTestTable(SQLiteConnection connection)
{
connection.Open();
connection.ExecuteNonQuery(@"
CREATE TABLE TestTable (
TestColumn INTEGER
)");
}
public void Dispose_can_be_called_more_than_once()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
CreateTestTable(connection);
var transaction = connection.BeginTransaction();
transaction.Dispose();
transaction.Dispose();
}
}
public void Dispose_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
CreateTestTable(connection);
using (var transaction = connection.BeginTransaction())
{
using (var command = connection.CreateCommand())
{
command.CommandText = "INSERT INTO TestTable VALUES (1)";
command.ExecuteNonQuery();
transaction.Dispose();
Assert.Null(connection.Transaction);
Assert.Null(transaction.Connection);
}
}
Assert.Equal(0L, connection.ExecuteScalar<long>("SELECT COUNT(*) FROM TestTable"));
}
}
public void Commit_throws_when_connection_closed()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
connection.Open();
using (var transaction = connection.BeginTransaction())
{
connection.Close();
var ex = Assert.Throws<InvalidOperationException>(() => transaction.Commit());
Assert.Equal(Strings.TransactionCompleted, ex.Message);
}
}
}
public void BeginTransaction_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
connection.Open();
using (var transaction = connection.BeginTransaction())
{
Assert.NotNull(transaction);
Assert.Same(transaction, connection.Transaction);
Assert.Equal(connection, transaction.Connection);
Assert.Equal(IsolationLevel.Serializable, transaction.IsolationLevel);
}
}
}
public void ServerVersion_returns_value()
{
using (var connection = new SQLiteConnection())
{
var version = connection.ServerVersion;
Assert.NotNull(version);
Assert.True(version.StartsWith("3."));
}
}
public void BeginTransaction_throws_when_parallel_transaction()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
connection.Open();
using (connection.BeginTransaction())
{
var ex = Assert.Throws<InvalidOperationException>(() => connection.BeginTransaction());
Assert.Equal(Strings.ParallelTransactionsNotSupported, ex.Message);
}
}
}
protected override void Dispose(bool disposing)
{
if (!disposing
|| _connection == null)
{
return;
}
if (_connection.State == ConnectionState.Open)
{
_connection.ExecuteNonQuery("ROLLBACK");
}
_connection.Transaction = null;
_connection = null;
}
public void ChangeDatabase_not_supported()
{
using (var connection = new SQLiteConnection())
{
Assert.Throws<NotSupportedException>(() => connection.ChangeDatabase("new"));
}
}