public void CanUpdateOnlyOneField(TestHelper.DatabaseType dbType, string connectionString)
{
var updatedName = "test updated";
var updatedNumber = 2;
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestClass>();
var testClass = new TestClass
{
Id = 1,
Name = "test",
FloatNumber = 1,
Done = true,
InsertDate = DateTime.Now,
TestClass2Id = 1
};
database.Insert(testClass);
testClass.Name = updatedName;
testClass.FloatNumber = updatedNumber;
database.UpdateOnly(testClass, t => t.Name, t => t.Id == 1);
var query = database.From <TestClass>().Where(t => t.Id == 1);
var result = database.SelectSingle(query);
Assert.AreEqual(updatedName, result.Name);
Assert.AreNotEqual(updatedNumber, result.FloatNumber);
}
}
public void CanUpdateOnlyManyFieldsWithoutIgnoredField(TestHelper.DatabaseType dbType, string connectionString)
{
var updatedName = "test updated";
var updatedNumber = 2;
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestIgnore>();
var testClass = new TestIgnore
{
Id = 1,
Name = "test",
Ignored = "ignored"
};
database.Insert(testClass);
testClass.Name = updatedName;
testClass.FloatNumber = updatedNumber;
database.UpdateOnly(testClass, t => new { t.Name }, t => t.Id == 1);
var query = database.From <TestIgnore>().Where(t => t.Id == 1);
var result = database.SelectSingle(query);
Assert.AreEqual(updatedName, result.Name);
Assert.AreNotEqual(updatedNumber, result.FloatNumber);
}
}
public void CanCreateAndDropDatabase(TestHelper.DatabaseType dbType, string connectionString)
{
using (var db = TestHelper.GetDatabaseFor(dbType, connectionString))
{
db.DropDatabaseIfExists("test_db");
db.CreateDatabase("test_db");
db.DropDatabase("test_db");
}
}
public void CanCreateTableOnlyIdentityColumn(TestHelper.DatabaseType dbType, string connectionString)
{
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestClassOnlyIdentity>();
database.Insert(new TestClassOnlyIdentity());
}
}
public void CanCreateIndex(TestHelper.DatabaseType dbType, string connectionString)
{
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestClass>();
database.CreateIndexIfNotExists <TestClass>(t => new { t.Id, t.Name }, true);
}
}
public void ExistsWhereReturnFalseWhenNotExists(TestHelper.DatabaseType dbType, string connectionString)
{
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestClass>();
Assert.IsFalse(database.Exists <TestClass>(t => t.Id == 1));
}
}
public void CanDropColumn(TestHelper.DatabaseType dbType, string connectionString)
{
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestClass>();
database.DropColumnIfExists <TestClass>(t => t.Name);
}
}
public void CanCreateTableIndex(TestHelper.DatabaseType dbType, string connectionString)
{
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestClassRef1>();
database.DropIndexIfExists <TestClassRef1>("IX_TestClassRef1_Id2");
database.DropIndexIfExists <TestClassRef1>("IX_TestTest");
}
}
public void CanCreateTableWithReferences(TestHelper.DatabaseType dbType, string connectionString)
{
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestClassRef1>();
database.CreateTableIfNotExists <TestClassRef2>(true);
database.DropForeignKeyIfExists <TestClassRef2>("FK_TestClassRef2");
}
}
public void CanCreateForeignKey(TestHelper.DatabaseType dbType, string connectionString)
{
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestClass>();
database.CreateTableIfNotExists <TestClass2>();
database.CreateForeignKeyIfNotExists <TestClass, TestClass2>(t => t.TestClass2Id, t => t.Id);
}
}
public void CanDropTable(TestHelper.DatabaseType dbType, string connectionString)
{
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestClass>();
database.Select(database.From <TestClass>().Where(t => t.Id == 1));
database.DropTableIfExists <TestClass>();
}
}
public void CanCreateTableWithOverridedName(TestHelper.DatabaseType dbType, string connectionString)
{
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestOverride>();
var query = database.From <TestOverride>().Where(t => t.Id == 1);
database.Select(query);
}
}
public void CanPaginateSelect(TestHelper.DatabaseType dbType, string connectionString)
{
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestClass>();
var query = database.From <TestClass>().Where(t => t.Id > 1).OrderBy(t => t.Id).Paginate(10, 2);
database.Select(query);
}
}
public void CanCreateTableWithoutIgnoredAttributes(TestHelper.DatabaseType dbType, string connectionString)
{
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestIgnore>();
var query = database.From <TestIgnore>().Where(t => t.Ignored == "exception!");
Assert.Throws(Is.InstanceOf <Exception>(), () => database.Select(query));
}
}
public void CanCheckIfTableExists(TestHelper.DatabaseType dbType, string connectionString)
{
using (var db = TestHelper.GetDatabaseFor(dbType, connectionString))
{
db.CreateTable <TestClass>();
Assert.That(db.TableExists <TestClass>(), Is.True);
db.DropTable <TestClass>();
Assert.That(db.TableExists <TestClass>(), Is.False);
}
}
public void CanCreateTable(TestHelper.DatabaseType dbType, string connectionString)
{
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTable<TestClass>();
var query = database.From<TestClass>().Where(t => t.Id == 1);
database.Select(query);
}
}
public void CanUseSelectSingleWhereOnDatabase(TestHelper.DatabaseType dbType, string connectionString)
{
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestClass>();
database.Insert(TestHelper.GetNewTestClass());
var obj = database.SelectSingle <TestClass>(t => t.Id == 1);
Assert.IsNotNull(obj);
}
}
public void CanDropIndex(TestHelper.DatabaseType dbType, string connectionString)
{
string indexName = "IX_TestClass_Id_Name";
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestClass>();
database.CreateIndexIfNotExists <TestClass>(t => new { t.Id, t.Name }, true, indexName);
database.DropIndexIfExists <TestClass>(indexName);
}
}
public void CanSelectById(TestHelper.DatabaseType dbType, string connectionString)
{
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestClass>();
database.Insert(TestHelper.GetNewTestClass());
var obj = database.SelectById <TestClass>(1);
Assert.IsNotNull(obj);
}
}
public void CanSelectSingle(TestHelper.DatabaseType dbType, string connectionString)
{
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestClass>();
database.Insert(TestHelper.GetNewTestClass());
var query = database.From <TestClass>().Where(t => t.Id == 1);
Assert.IsNotNull(database.SelectSingle(query));
}
}
public void ExistsWhereReturnTrueWhenExists(TestHelper.DatabaseType dbType, string connectionString)
{
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestIgnore>();
database.Insert(new TestIgnore {
Id = 1, FloatNumber = 1, Name = "test"
});
Assert.IsTrue(database.Exists <TestIgnore>(t => t.Id == 1));
}
}
public void CanUseSelectWhereOnDatabase(TestHelper.DatabaseType dbType, string connectionString)
{
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestClass>();
database.Insert(TestHelper.GetNewTestClass());
var objs = database.Select <TestClass>(t => t.Id == 1);
Assert.That(objs.Count(), Is.GreaterThan(0));
}
}
public void CanCheckIfIndexExistsWithDefaultName(TestHelper.DatabaseType dbType, string connectionString)
{
using (var db = TestHelper.GetDatabaseFor(dbType, connectionString))
{
db.CreateTable <TestClass>();
db.CreateIndex <TestClass>(t => t.Name);
Assert.That(db.IndexExists <TestClass>(t => t.Name), Is.True);
db.DropIndex <TestClass>("IX_TestClass_Name");
Assert.That(db.IndexExists <TestClass>(t => t.Name), Is.False);
}
}
public void CanCheckIfForeignKeyExistsWithDefaultName(TestHelper.DatabaseType dbType, string connectionString)
{
using (var db = TestHelper.GetDatabaseFor(dbType, connectionString))
{
db.CreateTables(typeof(TestClass), typeof(TestClass2));
db.CreateForeignKey <TestClass, TestClass2>(t => t.TestClass2Id, t2 => t2.Id);
Assert.That(db.ForeignKeyExists <TestClass, TestClass2>(t => t.TestClass2Id, t2 => t2.Id), Is.True);
db.DropForeignKey <TestClass>("FK_TestClass_TestCla");
Assert.That(db.ForeignKeyExists <TestClass, TestClass2>(t => t.TestClass2Id, t2 => t2.Id), Is.False);
}
}
public void CanCheckIfDatabaseExists(TestHelper.DatabaseType dbType, string connectionString)
{
using (var db = TestHelper.GetDatabaseFor(dbType, connectionString))
{
db.DropDatabaseIfExists("test_db");
db.CreateDatabase("test_db");
Assert.That(db.DatabaseExists("test_db"), Is.True);
db.DropDatabase("test_db");
Assert.That(db.DatabaseExists("test_db"), Is.False);
}
}
public void CanDropForeignKey(TestHelper.DatabaseType dbType, string connectionString)
{
string indexName = "FK_TestClass_Id";
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestClass>();
database.CreateTableIfNotExists <TestClass2>();
database.CreateForeignKeyIfNotExists <TestClass, TestClass2>(t => t.TestClass2Id, t => t.Id, indexName);
database.DropForeignKeyIfExists <TestClass>(indexName);
}
}
public void CanCreateTableNoReference(TestHelper.DatabaseType dbType, string connectionString)
{
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTable<TestClassNoReference>();
database.Insert(new TestClassNoReference { Id = 1 });
var result = database.SelectById<TestClassNoReference>(1);
Assert.That(result, Is.Not.Null);
Assert.That(result.Ref, Is.Null);
}
}
public void CanCreateTables(TestHelper.DatabaseType dbType, string connectionString)
{
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTablesIfNotExists(typeof(TestClass), typeof(TestClass2));
var query = database.From <TestClass>().Where(t => t.Id == 1);
database.Select(query);
var query2 = database.From <TestClass2>().Where(t => t.Id == 1);
database.Select(query2);
}
}
public void CanCreateTableWithIdentity(TestHelper.DatabaseType dbType, string connectionString)
{
using (var database = TestHelper.GetDatabaseFor(dbType, connectionString))
{
database.CreateTableIfNotExists <TestClass>();
database.Insert(TestHelper.GetNewTestClass(0));
database.Insert(TestHelper.GetNewTestClass(0));
var result = database.SelectById <TestClass>(1, 2);
Assert.AreEqual(2, result.Count());
}
}
public void CanCheckIfIndexExistsWithNamedIndex(TestHelper.DatabaseType dbType, string connectionString)
{
const string indexName = "IX_NAME";
using (var db = TestHelper.GetDatabaseFor(dbType, connectionString))
{
db.CreateTable <TestClass>();
db.CreateIndex <TestClass>(t => t.Name, false, indexName);
Assert.That(db.IndexExists <TestClass>(indexName), Is.True);
db.DropIndex <TestClass>(indexName);
Assert.That(db.IndexExists <TestClass>(indexName), Is.False);
}
}
