public void Should_Keep_The_Database_Connection_Open_If_keepConnectionOpen_Parameter_Was_True()
{
// Arrange
const string sql = @"
CREATE TABLE #SuperHero
(
SuperHeroId INT NOT NULL IDENTITY(1,1) PRIMARY KEY,
SuperHeroName NVARCHAR(120) NOT NULL
);
/* This insert should trigger 1 row affected */
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
";
var databaseCommand = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.SqlServerConnectionString)
.SetCommandText(sql);
// Act
var rowsAffected = databaseCommand.ExecuteNonQuery(true);
// Assert
Assert.That(databaseCommand.DbCommand.Connection.State == ConnectionState.Open);
// Cleanup
databaseCommand.Dispose();
}
public void Should_Keep_The_Database_Connection_Open_If_keepConnectionOpen_Parameter_Was_True()
{
// Arrange
const string sql = @"
CREATE TABLE IF NOT EXISTS SuperHero
(
SuperHeroId INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
SuperHeroName NVARCHAR(120) NOT NULL,
UNIQUE(SuperHeroName)
);
INSERT OR IGNORE INTO SuperHero VALUES ( NULL, 'Superman' ); /* This insert should trigger 1 row affected */
";
var databaseCommand = Sequelocity.GetDatabaseCommandForSQLite(ConnectionStringsNames.SqliteInMemoryDatabaseConnectionString)
.SetCommandText(sql);
// Act
var rowsAffected = databaseCommand.ExecuteNonQuery(true);
// Assert
Assert.That(databaseCommand.DbCommand.Connection.State == ConnectionState.Open);
// Cleanup
databaseCommand.Dispose();
}
public void Should_Call_The_DatabaseCommandUnhandledExceptionEventHandler()
{
// Arrange
bool wasUnhandledExceptionEventHandlerCalled = false;
Sequelocity.ConfigurationSettings.EventHandlers.DatabaseCommandUnhandledExceptionEventHandlers.Add((exception, command) =>
{
wasUnhandledExceptionEventHandlerCalled = true;
});
// Act
TestDelegate action = async() => await Sequelocity.GetDatabaseCommand(ConnectionStringsNames.SqlServerConnectionString)
.SetCommandText("asdf;lkj")
.ExecuteToMapAsync(record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue(0).ToLong(),
SuperHeroName = record.GetValue(1).ToString()
};
return(obj);
});
// Assert
Assert.Throws <System.Data.SqlClient.SqlException>(action);
Assert.IsTrue(wasUnhandledExceptionEventHandlerCalled);
}
public void Should_Null_The_DbCommand_By_Default()
{
// Arrange
const string sql = @"
CREATE TABLE IF NOT EXISTS SuperHero
(
SuperHeroId INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
SuperHeroName NVARCHAR(120) NOT NULL,
UNIQUE(SuperHeroName)
);
INSERT OR IGNORE INTO SuperHero VALUES ( NULL, 'Superman' );
SELECT SuperHeroId, /* This should be the only value returned from ExecuteScalar */
SuperHeroName
FROM SuperHero;
";
var databaseCommand = Sequelocity.GetDatabaseCommandForSQLite(ConnectionStringsNames.SqliteInMemoryDatabaseConnectionString)
.SetCommandText(sql);
// Act
databaseCommand.ExecuteToDynamicObjectAsync()
.Wait(); // Block until the task completes.
// Assert
Assert.IsNull(databaseCommand.DbCommand);
}
public void Should_Null_The_DbCommand_By_Default()
{
// Arrange
const string sql = @"
DROP TABLE IF EXISTS SuperHero;
CREATE TEMPORARY TABLE SuperHero
(
SuperHeroId serial not null,
SuperHeroName VARCHAR(120) NOT NULL,
PRIMARY KEY ( SuperHeroId )
);
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM SuperHero;
";
var databaseCommand = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.PostgreSQLConnectionString)
.SetCommandText(sql);
// Act
var superHeroes = databaseCommand.ExecuteToList <SuperHero>();
// Assert
Assert.IsNull(databaseCommand.DbCommand);
}
public void Should_Map_The_Results_Back_To_A_List_Of_Dynamic()
{
// Arrange
const string sql = @"
CREATE TABLE IF NOT EXISTS SuperHero
(
SuperHeroId INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
SuperHeroName NVARCHAR(120) NOT NULL,
UNIQUE(SuperHeroName)
);
INSERT OR IGNORE INTO SuperHero VALUES ( NULL, 'Superman' );
INSERT OR IGNORE INTO SuperHero VALUES ( NULL, 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM SuperHero;
";
// Act
var superHero = Sequelocity.GetDatabaseCommandForSQLite(ConnectionStringsNames.SqliteInMemoryDatabaseConnectionString)
.SetCommandText(sql)
.ExecuteToDynamicObject();
// Assert
Assert.NotNull(superHero);
Assert.That(superHero.SuperHeroId == 1);
Assert.That(superHero.SuperHeroName == "Superman");
}
public void Should_Keep_The_Database_Connection_Open_If_keepConnectionOpen_Parameter_Was_True()
{
// Arrange
const string sql = @"
DROP TABLE IF EXISTS SuperHero;
CREATE TEMPORARY TABLE SuperHero
(
SuperHeroId serial not null primary key,
SuperHeroName VARCHAR(120) NOT NULL
);
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM SuperHero;
";
var databaseCommand = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.PostgreSQLConnectionString)
.SetCommandText(sql);
// Act
databaseCommand.ExecuteToDynamicListAsync(true)
.Wait(); // Block until the task completes.
// Assert
Assert.That(databaseCommand.DbCommand.Connection.State == ConnectionState.Open);
// Cleanup
databaseCommand.Dispose();
}
public void Should_Return_The_First_Column_Of_The_First_Row_In_The_Result_Set()
{
// Arrange
const string sql = @"
CREATE TABLE IF NOT EXISTS SuperHero
(
SuperHeroId INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
SuperHeroName NVARCHAR(120) NOT NULL,
UNIQUE(SuperHeroName)
);
INSERT OR IGNORE INTO SuperHero VALUES ( NULL, 'Superman' );
SELECT SuperHeroId, /* This should be the only value returned from ExecuteScalar */
SuperHeroName
FROM SuperHero;
";
// Act
var superHeroId = Sequelocity.GetDatabaseCommandForSQLite(ConnectionStringsNames.SqliteInMemoryDatabaseConnectionString)
.SetCommandText(sql)
.ExecuteScalar()
.ToLong();
// Assert
Assert.That(superHeroId == 1);
}
public void Should_Be_Able_To_Specify_The_Table_Name()
{
// Arrange
const string createSchemaSql = @"
DROP TABLE IF EXISTS Person;
CREATE TABLE IF NOT EXISTS Person
(
CustomerId INT NOT NULL AUTO_INCREMENT,
FirstName NVARCHAR(120) NOT NULL,
LastName NVARCHAR(120) NOT NULL,
DateOfBirth DATETIME NOT NULL,
PRIMARY KEY ( CustomerId )
);
";
Sequelocity.GetDatabaseCommand(ConnectionStringsNames.MySqlConnectionString)
.SetCommandText(createSchemaSql)
.ExecuteNonQuery();
var customer = new Customer {
FirstName = "Clark", LastName = "Kent", DateOfBirth = DateTime.Parse("06/18/1938")
};
// Act
var customerId = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.MySqlConnectionString)
.GenerateInsertForMySql(customer, "Person") // Specifying a table name of Person
.ExecuteScalar <int>();
// Assert
Assert.That(customerId == 1);
}
public void Should_Return_A_Task_Resulting_In_A_Map_Of_The_Results_To_A_List_Of_Type_T()
{
// Arrange
const string sql = @"
CREATE TABLE IF NOT EXISTS SuperHero
(
SuperHeroId INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
SuperHeroName NVARCHAR(120) NOT NULL,
UNIQUE(SuperHeroName)
);
INSERT OR IGNORE INTO SuperHero VALUES ( NULL, 'Superman' );
INSERT OR IGNORE INTO SuperHero VALUES ( NULL, 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM SuperHero;
";
// Act
var superHeroesTask = Sequelocity.GetDatabaseCommandForSQLite(ConnectionStringsNames.SqliteInMemoryDatabaseConnectionString)
.SetCommandText(sql)
.ExecuteToListAsync <SuperHero>();
// Assert
Assert.IsInstanceOf <Task <List <SuperHero> > >(superHeroesTask);
Assert.That(superHeroesTask.Result.Count == 2);
Assert.That(superHeroesTask.Result[0].SuperHeroId == 1);
Assert.That(superHeroesTask.Result[0].SuperHeroName == "Superman");
Assert.That(superHeroesTask.Result[1].SuperHeroId == 2);
Assert.That(superHeroesTask.Result[1].SuperHeroName == "Batman");
}
public void Should_Return_A_Task_Resulting_In_A_Map_Of_The_Results_To_A_List_Of_Type_T()
{
// Arrange
const string sql = @"
CREATE TABLE #SuperHero
(
SuperHeroId INT NOT NULL IDENTITY(1,1) PRIMARY KEY,
SuperHeroName NVARCHAR(120) NOT NULL
);
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM #SuperHero;
";
// Act
var superHeroesTask = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.SqlServerConnectionString)
.SetCommandText(sql)
.ExecuteToListAsync <SuperHero>();
// Assert
Assert.IsInstanceOf <Task <List <SuperHero> > >(superHeroesTask);
Assert.That(superHeroesTask.Result.Count == 2);
Assert.That(superHeroesTask.Result[0].SuperHeroId == 1);
Assert.That(superHeroesTask.Result[0].SuperHeroName == "Superman");
Assert.That(superHeroesTask.Result[1].SuperHeroId == 2);
Assert.That(superHeroesTask.Result[1].SuperHeroName == "Batman");
}
public void Should_Return_A_Type_Of_T()
{
// Arrange
const string sql = @"
DROP TABLE IF EXISTS SuperHero;
CREATE TEMPORARY TABLE SuperHero
(
SuperHeroId serial not null,
SuperHeroName VARCHAR(120) NOT NULL,
PRIMARY KEY ( SuperHeroId )
);
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM SuperHero;
";
// Act
var superHero = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.PostgreSQLConnectionString)
.SetCommandText(sql)
.ExecuteToObject <SuperHero>();
// Assert
Assert.NotNull(superHero);
Assert.That(superHero.SuperHeroId == 1);
Assert.That(superHero.SuperHeroName == "Superman");
}
public void Should_Throw_An_Exception_When_Passing_An_Anonymous_Object_And_Not_Specifying_A_TableName()
{
// Arrange
const string sql = @"
CREATE TABLE IF NOT EXISTS Person
(
CustomerId INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
FirstName NVARCHAR(120) NOT NULL,
LastName NVARCHAR(120) NOT NULL,
DateOfBirth DATETIME NOT NULL
);";
var dbConnection = Sequelocity.CreateDbConnection(ConnectionStringsNames.SqliteInMemoryDatabaseConnectionString);
new DatabaseCommand(dbConnection)
.SetCommandText(sql)
.ExecuteNonQuery(true);
var customer1 = new { FirstName = "Clark", LastName = "Kent", DateOfBirth = DateTime.Parse("06/18/1938") };
var customer2 = new { FirstName = "Bruce", LastName = "Wayne", DateOfBirth = DateTime.Parse("05/27/1939") };
var customer3 = new { FirstName = "Peter", LastName = "Parker", DateOfBirth = DateTime.Parse("08/18/1962") };
var list = new List <object> {
customer1, customer2, customer3
};
// Act
TestDelegate action = () => new DatabaseCommand(dbConnection)
.GenerateInsertsForSQLite(list)
.ExecuteScalar(true)
.ToInt();
// Assert
var exception = Assert.Catch <ArgumentNullException>(action);
Assert.That(exception.Message.Contains("The 'tableName' parameter must be provided when the object supplied is an anonymous type."));
}
public void Should_Return_A_DataSet()
{
// Arrange
const string sql = @"
CREATE TABLE #SuperHero
(
SuperHeroId INT NOT NULL IDENTITY(1,1) PRIMARY KEY,
SuperHeroName NVARCHAR(120) NOT NULL
);
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM #SuperHero;
";
// Act
var dataSet = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.SqlServerConnectionString)
.SetCommandText(sql)
.ExecuteToDataSet();
// Assert
Assert.That(dataSet.Tables[0].Rows.Count == 2);
Assert.That(dataSet.Tables[0].Rows[0][0].ToString() == "1");
Assert.That(dataSet.Tables[0].Rows[0][1].ToString() == "Superman");
Assert.That(dataSet.Tables[0].Rows[1][0].ToString() == "2");
Assert.That(dataSet.Tables[0].Rows[1][1].ToString() == "Batman");
}
public void Should_Keep_The_Database_Connection_Open_If_keepConnectionOpen_Parameter_Was_True()
{
// Arrange
const string sql = @"
CREATE TABLE #SuperHero
(
SuperHeroId INT NOT NULL IDENTITY(1,1) PRIMARY KEY,
SuperHeroName NVARCHAR(120) NOT NULL
);
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM #SuperHero;
";
var databaseCommand = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.SqlServerConnectionString)
.SetCommandText(sql);
// Act
var superHeroes = databaseCommand.ExecuteToDynamicList(true);
// Assert
Assert.That(databaseCommand.DbCommand.Connection.State == ConnectionState.Open);
// Cleanup
databaseCommand.Dispose();
}
public void Should_Throw_An_Exception_When_Passing_An_Anonymous_Object_And_Not_Specifying_A_TableName()
{
// Arrange
const string createSchemaSql = @"
DROP TABLE IF EXISTS Customer;
CREATE TABLE IF NOT EXISTS Customer
(
CustomerId INT NOT NULL AUTO_INCREMENT,
FirstName NVARCHAR(120) NOT NULL,
LastName NVARCHAR(120) NOT NULL,
DateOfBirth DATETIME NOT NULL,
PRIMARY KEY ( CustomerId )
);
";
Sequelocity.GetDatabaseCommand(ConnectionStringsNames.MySqlConnectionString)
.SetCommandText(createSchemaSql)
.ExecuteNonQuery();
var customer = new { FirstName = "Clark", LastName = "Kent", DateOfBirth = DateTime.Parse("06/18/1938") };
// Act
TestDelegate action = () => Sequelocity.GetDatabaseCommand(ConnectionStringsNames.MySqlConnectionString)
.GenerateInsertForMySql(customer)
.ExecuteScalar <int>();
// Assert
var exception = Assert.Catch <ArgumentNullException>(action);
Assert.That(exception.Message.Contains("The 'tableName' parameter must be provided when the object supplied is an anonymous type."));
}
public void Should_Null_The_DbCommand_If_Iteration_Ends_Before_Full_Enumeration()
{
// Arrange
const string sql = @"
CREATE TABLE #SuperHero
(
SuperHeroId INT NOT NULL IDENTITY(1,1) PRIMARY KEY,
SuperHeroName NVARCHAR(120) NOT NULL
);
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM #SuperHero;
";
var databaseCommand = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.SqlServerConnectionString)
.SetCommandText(sql);
// Act
databaseCommand
.ExecuteReader(record => new
{
SuperHeroId = record.GetValue(0),
SuperHeroName = record.GetValue(1)
})
.First();
// Assert
Assert.IsNull(databaseCommand.DbCommand);
}
public void Should_Return_The_Last_Inserted_Id()
{
// Arrange
const string createSchemaSql = @"
DROP TABLE IF EXISTS Customer;
CREATE TABLE IF NOT EXISTS Customer
(
CustomerId INT NOT NULL AUTO_INCREMENT,
FirstName NVARCHAR(120) NOT NULL,
LastName NVARCHAR(120) NOT NULL,
DateOfBirth DATETIME NOT NULL,
PRIMARY KEY ( CustomerId )
);
";
Sequelocity.GetDatabaseCommand(ConnectionStringsNames.MySqlConnectionString)
.SetCommandText(createSchemaSql)
.ExecuteNonQuery();
var customer = new Customer {
FirstName = "Clark", LastName = "Kent", DateOfBirth = DateTime.Parse("06/18/1938")
};
// Act
var customerId = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.MySqlConnectionString)
.GenerateInsertForMySql(customer)
.ExecuteScalar()
.ToInt();
// Assert
Assert.That(customerId == 1);
}
public void Should_Null_The_DbCommand_By_Default()
{
// Arrange
const string sql = @"
DROP TABLE IF EXISTS SuperHero;
CREATE TEMPORARY TABLE SuperHero
(
SuperHeroId serial not null primary key,
SuperHeroName VARCHAR(120) NOT NULL
);
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM SuperHero;
";
var databaseCommand = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.PostgreSQLConnectionString)
.SetCommandText(sql);
// Act
databaseCommand.ExecuteToDynamicListAsync()
.Wait(); // Block until the task completes.
// Assert
Assert.IsNull(databaseCommand.DbCommand);
}
public void Should_Return_A_Task_Resulting_In_The_Number_Of_Affected_Rows()
{
// Arrange
const string sql = @"
DROP TEMPORARY TABLE IF EXISTS SuperHero;
CREATE TEMPORARY TABLE SuperHero
(
SuperHeroId INT NOT NULL AUTO_INCREMENT,
SuperHeroName VARCHAR(120) NOT NULL,
PRIMARY KEY ( SuperHeroId )
);
INSERT INTO SuperHero ( SuperHeroName ) VALUES ( 'Superman' ); /* This insert should trigger 1 row affected */
";
// Act
var rowsAffectedTask = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.MySqlConnectionString)
.SetCommandText(sql)
.ExecuteNonQueryAsync();
// Assert
Assert.IsInstanceOf <Task <int> >(rowsAffectedTask);
Assert.That(rowsAffectedTask.Result == 1);
}
public void Should_Return_A_Task_Resulting_In_A_Map_Of_The_First_Result_To_A_Dynamic_Object()
{
// Arrange
const string sql = @"
CREATE TABLE IF NOT EXISTS SuperHero
(
SuperHeroId INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
SuperHeroName NVARCHAR(120) NOT NULL,
UNIQUE(SuperHeroName)
);
INSERT OR IGNORE INTO SuperHero VALUES ( NULL, 'Superman' );
INSERT OR IGNORE INTO SuperHero VALUES ( NULL, 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM SuperHero;
";
// Act
var superHeroTask = Sequelocity.GetDatabaseCommandForSQLite(ConnectionStringsNames.SqliteInMemoryDatabaseConnectionString)
.SetCommandText(sql)
.ExecuteToDynamicObjectAsync();
// Assert
Assert.IsInstanceOf <Task <dynamic> >(superHeroTask);
Assert.NotNull(superHeroTask.Result);
Assert.That(superHeroTask.Result.SuperHeroId == 1);
Assert.That(superHeroTask.Result.SuperHeroName == "Superman");
}
public void Should_Null_The_DbCommand_By_Default()
{
// Arrange
const string sql = @"
DROP TEMPORARY TABLE IF EXISTS SuperHero;
CREATE TEMPORARY TABLE SuperHero
(
SuperHeroId INT NOT NULL AUTO_INCREMENT,
SuperHeroName VARCHAR(120) NOT NULL,
PRIMARY KEY ( SuperHeroId )
);
INSERT INTO SuperHero ( SuperHeroName ) VALUES ( 'Superman' ); /* This insert should trigger 1 row affected */
";
var databaseCommand = Sequelocity.GetDatabaseCommandForMySql(ConnectionStringsNames.MySqlConnectionString)
.SetCommandText(sql);
// Act
databaseCommand.ExecuteNonQueryAsync()
.Wait(); // Block until the task completes.
// Assert
Assert.IsNull(databaseCommand.DbCommand);
}
public void Should_Keep_The_Database_Connection_Open_If_keepConnectionOpen_Parameter_Was_True()
{
// Arrange
const string sql = @"
CREATE TABLE IF NOT EXISTS SuperHero
(
SuperHeroId INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
SuperHeroName NVARCHAR(120) NOT NULL,
UNIQUE(SuperHeroName)
);
INSERT OR IGNORE INTO SuperHero VALUES ( NULL, 'Superman' );
SELECT SuperHeroId, /* This should be the only value returned from ExecuteScalar */
SuperHeroName
FROM SuperHero;
";
var databaseCommand = Sequelocity.GetDatabaseCommandForSQLite(ConnectionStringsNames.SqliteInMemoryDatabaseConnectionString)
.SetCommandText(sql);
// Act
databaseCommand.ExecuteToDynamicObjectAsync(true)
.Wait(); // Block until the task completes.
// Assert
Assert.That(databaseCommand.DbCommand.Connection.State == ConnectionState.Open);
// Cleanup
databaseCommand.Dispose();
}
public void Should_Keep_The_Database_Connection_Open_If_keepConnectionOpen_Parameter_Was_True()
{
// Arrange
const string sql = @"
DROP TEMPORARY TABLE IF EXISTS SuperHero;
CREATE TEMPORARY TABLE SuperHero
(
SuperHeroId INT NOT NULL AUTO_INCREMENT,
SuperHeroName VARCHAR(120) NOT NULL,
PRIMARY KEY ( SuperHeroId )
);
INSERT INTO SuperHero ( SuperHeroName ) VALUES ( 'Superman' ); /* This insert should trigger 1 row affected */
";
var databaseCommand = Sequelocity.GetDatabaseCommandForMySql(ConnectionStringsNames.MySqlConnectionString)
.SetCommandText(sql);
// Act
databaseCommand.ExecuteNonQueryAsync(true)
.Wait(); // Block until the task completes.
// Assert
Assert.That(databaseCommand.DbCommand.Connection.State == ConnectionState.Open);
// Cleanup
databaseCommand.Dispose();
}
public void Should_Keep_The_Database_Connection_Open_If_keepConnectionOpen_Parameter_Was_True()
{
// Arrange
const string sql = @"
DROP TABLE IF EXISTS SuperHero;
CREATE TEMPORARY TABLE SuperHero
(
SuperHeroId serial not null,
SuperHeroName VARCHAR(120) NOT NULL,
PRIMARY KEY ( SuperHeroId )
);
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM SuperHero;
";
var databaseCommand = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.PostgreSQLConnectionString)
.SetCommandText(sql);
// Act
var superHeroes = databaseCommand.ExecuteToList <SuperHero>(true);
// Assert
Assert.That(databaseCommand.DbCommand.Connection.State == ConnectionState.Open);
// Cleanup
databaseCommand.Dispose();
}
public void Should_Map_The_Results_Back_To_A_List_Of_Dynamic()
{
// Arrange
const string sql = @"
CREATE TABLE #SuperHero
(
SuperHeroId INT NOT NULL IDENTITY(1,1) PRIMARY KEY,
SuperHeroName NVARCHAR(120) NOT NULL
);
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM #SuperHero;
";
// Act
var superHeroes = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.SqlServerConnectionString)
.SetCommandText(sql)
.ExecuteToDynamicList();
// Assert
Assert.That(superHeroes.Count == 2);
Assert.That(superHeroes[0].SuperHeroId == 1);
Assert.That(superHeroes[0].SuperHeroName == "Superman");
Assert.That(superHeroes[1].SuperHeroId == 2);
Assert.That(superHeroes[1].SuperHeroName == "Batman");
}
public void Should_Call_The_DatabaseCommandPostExecuteEventHandler()
{
// Arrange
bool wasPostExecuteEventHandlerCalled = false;
Sequelocity.ConfigurationSettings.EventHandlers.DatabaseCommandPostExecuteEventHandlers.Add(command => wasPostExecuteEventHandlerCalled = true);
// Act
Sequelocity.GetDatabaseCommand(ConnectionStringsNames.SqlServerConnectionString)
.SetCommandText("SELECT 1 as SuperHeroId, 'Superman' as SuperHeroName")
.ExecuteToMapAsync(record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue(0).ToLong(),
SuperHeroName = record.GetValue(1).ToString()
};
return(obj);
})
.Wait(); // Block until the task completes.
// Assert
Assert.IsTrue(wasPostExecuteEventHandlerCalled);
}
public void Should_Null_The_DbCommand_By_Default()
{
// Arrange
const string sql = @"
CREATE TABLE #SuperHero
(
SuperHeroId INT NOT NULL IDENTITY(1,1) PRIMARY KEY,
SuperHeroName NVARCHAR(120) NOT NULL
);
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM #SuperHero;
";
var databaseCommand = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.SqlServerConnectionString)
.SetCommandText(sql);
// Act
var superHeroes = databaseCommand.ExecuteToDynamicList();
// Assert
Assert.IsNull(databaseCommand.DbCommand);
}
public void Should_Return_A_Task_Resulting_In_A_Map_Of_The_First_Result_To_A_Dynamic_Object()
{
// Arrange
const string sql = @"
DROP TABLE IF EXISTS SuperHero;
CREATE TEMPORARY TABLE SuperHero
(
SuperHeroId serial not null primary key,
SuperHeroName VARCHAR(120) NOT NULL
);
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM SuperHero;
";
// Act
var superHeroTask = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.PostgreSQLConnectionString)
.SetCommandText(sql)
.ExecuteToDynamicObjectAsync();
// Assert
Assert.IsInstanceOf <Task <dynamic> >(superHeroTask);
Assert.NotNull(superHeroTask.Result);
Assert.That(superHeroTask.Result.SuperHeroId == 1);
Assert.That(superHeroTask.Result.SuperHeroName == "Superman");
}
public void Should_Return_A_Task_Resulting_In_A_Map_Of_The_First_Result_To_A_Dynamic_Object()
{
// Arrange
const string sql = @"
CREATE TABLE #SuperHero
(
SuperHeroId INT NOT NULL IDENTITY(1,1) PRIMARY KEY,
SuperHeroName NVARCHAR(120) NOT NULL
);
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM #SuperHero;
";
// Act
var superHeroTask = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.SqlServerConnectionString)
.SetCommandText(sql)
.ExecuteToDynamicObjectAsync();
// Assert
Assert.IsInstanceOf <Task <dynamic> >(superHeroTask);
Assert.NotNull(superHeroTask.Result);
Assert.That(superHeroTask.Result.SuperHeroId == 1);
Assert.That(superHeroTask.Result.SuperHeroName == "Superman");
}