public void TestSum(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
AssertValues(databaseServices, databaseServices.DMLService.AggregateFunctions.Sum("AGE"), 51);
AssertValues(databaseServices, databaseServices.DMLService.AggregateFunctions.Sum("WEIGHT"), 181.4M);
}
public void TransformRuntimeToDatabaseValueReplacesEmptyStringsWithZeros(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
var executionService = databaseServices.ExecutionService;
var numericTypes = new DbType[] {
DbType.Int16, DbType.Int32, DbType.Int64,
DbType.UInt16, DbType.UInt32, DbType.UInt64,
DbType.Byte, DbType.SByte
};
var decimalTypes = new DbType[] {
DbType.Currency, DbType.Decimal,
DbType.Single, DbType.Double,
DbType.VarNumeric
};
object value = null;
foreach (var numType in numericTypes)
{
value = executionService.TransformRuntimeToDatabaseValue(numType, "");
Assert.AreEqual(0, value);
}
foreach (var decType in decimalTypes)
{
value = executionService.TransformRuntimeToDatabaseValue(decType, "");
Assert.AreEqual(new Decimal(0), value);
}
}
public void CheckIfEveryAnnotatedPropertyHasSupportedType(DatabaseProviderTestCase tc)
{
Func <Type, bool> IsSupported = (t) => {
var supportedTypes = new List <Type> {
typeof(int),
typeof(string),
typeof(bool)
};
return(t.IsEnum || supportedTypes.Contains(t));
};
var wrapper = new MetaDatabaseConfiguration(CreateIntegrationDatabaseConfiguration(tc));
var writer = new StringWriter();
foreach (var parameter in wrapper.Parameters)
{
if (!IsSupported(parameter.Type))
{
writer.WriteLine("Parameter " + parameter.Name + " has annottated property with unsupported type " + parameter.Type);
}
}
var errorMessages = writer.ToString();
Assert.AreEqual(string.Empty, errorMessages, errorMessages);
}
public void TestUpdateEntity(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
IDMLEntityActions dmlEntityActions = GetDMLEntityActions(databaseServices);
IDictionary <UpdatePlaceholder, string> updatePlaceholders = dmlEntityActions.SQLPlaceholderValuesForUpdate();
string beforeStatement = updatePlaceholders.GetPlaceholderValueTrimStart(UpdatePlaceholder.BeforeStatement);
string beforeWhereKeyword = updatePlaceholders.GetPlaceholderValueTrimStart(UpdatePlaceholder.BeforeWhereKeyword);
string afterStatement = updatePlaceholders.GetPlaceholderValueTrimEnd(UpdatePlaceholder.AfterStatement);
int value = 2;
string updateSql = beforeStatement + "UPDATE DUMMY" + MachineName + " SET VAL = " + value + " " + beforeWhereKeyword + "WHERE ID = 1" + afterStatement;
string selectSql = "SELECT VAL FROM DUMMY" + MachineName + " WHERE ID = 1";
ExecuteSQL(databaseServices, (service, tran) => {
using (IDbCommand cmd = service.CreateCommand(tran, updateSql)) {
service.ExecuteNonQuery(cmd);
}
int updatedValue;
using (IDbCommand cmd = service.CreateCommand(tran, selectSql)) {
updatedValue = (int)Convert.ChangeType(service.ExecuteScalar(cmd), typeof(int));
}
AssertEqual(value, updatedValue, string.Format(errorMessageFormat, "UpdateEntity", updateSql));
return(true);
});
}
public void TestGetEntityForUpdate(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
IDMLEntityActions dmlEntityActions = GetDMLEntityActions(databaseServices);
InnerGetEntity(databaseServices, dmlEntityActions.SQLPlaceholderValuesForGetForUpdate(), /*forUpdate*/ true);
}
public void TestCreateEntity(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
IDMLEntityActions dmlEntityActions = GetDMLEntityActions(databaseServices);
IDictionary <InsertPlaceholder, string> insertPlaceholders = dmlEntityActions.SQLPlaceholderValuesForCreate();
string beforeStatement = insertPlaceholders.GetPlaceholderValueTrimStart(InsertPlaceholder.BeforeStatement);
string beforeValuesKeyword = insertPlaceholders.GetPlaceholderValueTrimStart(InsertPlaceholder.BeforeValuesKeyword);
string afterStatement = insertPlaceholders.GetPlaceholderValueTrimEnd(InsertPlaceholder.AfterStatement);
int value = 2;
string insertSql = beforeStatement + "INSERT INTO DUMMY" + MachineName + " (VAL) " + beforeValuesKeyword + "VALUES (" + value + ")" + afterStatement;
string selectSql = "SELECT VAL FROM DUMMY" + MachineName + " WHERE VAL = " + value;
ExecuteSQL(databaseServices, (service, tran) => {
using (IDbCommand cmd = service.CreateCommand(tran, insertSql)) {
service.ExecuteNonQuery(cmd);
}
int insertedValue;
using (IDbCommand cmd = service.CreateCommand(tran, selectSql)) {
insertedValue = (int)Convert.ChangeType(service.ExecuteScalar(cmd), typeof(int));
}
AssertEqual(value, insertedValue, string.Format(errorMessageFormat, "CreateEntity", insertSql));
return(true);
});
}
public void TestAvg(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
AssertValues(databaseServices, databaseServices.DMLService.AggregateFunctions.Avg("AGE"), 25.5M);
AssertValues(databaseServices, databaseServices.DMLService.AggregateFunctions.Avg("WEIGHT"), 90.7M);
}
public void TestGetTableSourceDetailsWithForeignKeys(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
AssertForeignKeys(expectedForeignKeys,
databaseServices.IntrospectionService.GetTableSourceForeignKeys(GetTableSourceInfo(databaseServices, tableForeignKeysTable.Name)));
}
public void TestSubtract(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
AssertValue(databaseServices, "Subtract", "SELECT " + databaseServices.DMLService.Operators.Subtract("{0}", "{1}") + " FROM DUMMY" + MachineName, 0, 1, 1);
AssertValue(databaseServices, "Subtract", "SELECT " + databaseServices.DMLService.Operators.Subtract("{0}", "{1}") + " FROM DUMMY" + MachineName, -2, -4, -2);
AssertValue(databaseServices, "Subtract", "SELECT " + databaseServices.DMLService.Operators.Subtract("{0}", "{1}") + " FROM DUMMY" + MachineName, 0.86m, 4m, 3.14m);
}
public void TestNot(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
string ageEqual = databaseServices.DMLService.Operators.Equal("AGE", "{0}");
string notExpression = databaseServices.DMLService.Operators.Not(ageEqual);
AssertValue(databaseServices, "Not", "SELECT PERSONID FROM PERSON" + MachineName + " WHERE " + notExpression, Person.DaveLauper.PersonId, Person.JohnOps.Age);
}
public void TestMultiply(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
AssertValue(databaseServices, "Multiply", "SELECT " + databaseServices.DMLService.Operators.Multiply("{0}", "{1}") + " FROM DUMMY" + MachineName, 0, 1, 0);
AssertValue(databaseServices, "Multiply", "SELECT " + databaseServices.DMLService.Operators.Multiply("{0}", "{1}") + " FROM DUMMY" + MachineName, -1, -1, 1);
AssertValue(databaseServices, "Multiply", "SELECT " + databaseServices.DMLService.Operators.Multiply("{0}", "{1}") + " FROM DUMMY" + MachineName, 6m, 2m, 3m);
}
public void TestDivide(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
AssertValue(databaseServices, "Divide", "SELECT " + databaseServices.DMLService.Operators.Divide("{0}", "{1}") + " FROM DUMMY" + MachineName, 0m, 0m, 1m);
AssertValue(databaseServices, "Divide", "SELECT " + databaseServices.DMLService.Operators.Divide("{0}", "{1}") + " FROM DUMMY" + MachineName, -1m, -1m, 1m);
AssertValue(databaseServices, "Divide", "SELECT " + databaseServices.DMLService.Operators.Divide("{0}", "{1}") + " FROM DUMMY" + MachineName, 1.5m, 3m, 2m);
}
public void TestAdd(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
AssertValue(databaseServices, "Add", "SELECT " + databaseServices.DMLService.Operators.Add("{0}", "{1}") + " FROM DUMMY" + MachineName, 2, 1, 1);
AssertValue(databaseServices, "Add", "SELECT " + databaseServices.DMLService.Operators.Add("{0}", "{1}") + " FROM DUMMY" + MachineName, 0, 1, -1);
AssertValue(databaseServices, "Add", "SELECT " + databaseServices.DMLService.Operators.Add("{0}", "{1}") + " FROM DUMMY" + MachineName, 4m, 3.14m, 0.86m);
}
public void TestListDatabasesFindCurrentDatabase(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
IEnumerable <IDatabaseInfo> databases = databaseServices.IntrospectionService.ListDatabases();
IDatabaseInfo currentDBInfo = databaseServices.ObjectFactory.CreateDatabaseInfo(GetDatabaseIdentifier(databaseServices));
Assert.IsNotNull(databases.FirstOrDefault(db => db.Equals(currentDBInfo)), "Current database (" + currentDBInfo.Identifier + ") not found in the list.");
}
public void TestMax(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
AssertValues(databaseServices, databaseServices.DMLService.AggregateFunctions.Max("PERSONID"), 3);
AssertValues(databaseServices, databaseServices.DMLService.AggregateFunctions.Max("AGE"), 30);
AssertValues(databaseServices, databaseServices.DMLService.AggregateFunctions.Max("WEIGHT"), 100.9M);
AssertValues(databaseServices, databaseServices.DMLService.AggregateFunctions.Max("LASTLOGIN"), new DateTime(2014, 3, 14, 10, 0, 36));
}
public void TestLessThan(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
AssertValue(databaseServices, "LessThan", "SELECT PERSONID FROM PERSON" + MachineName + " WHERE " + databaseServices.DMLService.Operators.LessThen("NAME", "{0}"), Person.DaveLauper.PersonId, Person.JohnOps.Name);
AssertValue(databaseServices, "LessThan", "SELECT PERSONID FROM PERSON" + MachineName + " WHERE " + databaseServices.DMLService.Operators.LessThen("AGE", "{0}"), Person.DaveLauper.PersonId, Person.JohnOps.Age);
AssertValue(databaseServices, "LessThan", "SELECT PERSONID FROM PERSON" + MachineName + " WHERE " + databaseServices.DMLService.Operators.LessThen("WEIGHT", "{0}"), Person.DaveLauper.PersonId, Person.JohnOps.Weight);
AssertValue(databaseServices, "LessThan", "SELECT PERSONID FROM PERSON" + MachineName + " WHERE " + databaseServices.DMLService.Operators.LessThen("LASTLOGIN", "{0}"), Person.DaveLauper.PersonId, Person.JohnOps.LastLogin);
}
public void TestMin(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
AssertValues(databaseServices, databaseServices.DMLService.AggregateFunctions.Min("PERSONID"), 1);
AssertValues(databaseServices, databaseServices.DMLService.AggregateFunctions.Min("AGE"), 21);
AssertValues(databaseServices, databaseServices.DMLService.AggregateFunctions.Min("WEIGHT"), 80.5M);
AssertValues(databaseServices, databaseServices.DMLService.AggregateFunctions.Min("LASTLOGIN"), new DateTime(2014, 3, 13, 14, 50, 23));
}
public void TestConcatenate(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
AssertValue(databaseServices, "Concatenate", "SELECT " + databaseServices.DMLService.Operators.Concatenate("{0}", "{1}") + " FROM DUMMY" + MachineName, "DaveLauper", "Dave", "Lauper");
AssertValue(databaseServices, "Concatenate", "SELECT " + databaseServices.DMLService.Operators.Concatenate("{0}", "{1}") + " FROM DUMMY" + MachineName, "Dave", "Dave", "");
AssertValue(databaseServices, "Concatenate", "SELECT " + databaseServices.DMLService.Operators.Concatenate("{0}", "{1}") + " FROM DUMMY" + MachineName, "Lauper", "", "Lauper");
AssertValue(databaseServices, "Concatenate", "SELECT " + databaseServices.DMLService.Operators.Concatenate("{0}", "{1}") + " FROM DUMMY" + MachineName, "", "", "");
}
public void TestNegative(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
AssertValue(databaseServices, "Negative", "SELECT " + databaseServices.DMLService.Operators.Negative("{0}") + " FROM DUMMY" + MachineName, -1, 1);
AssertValue(databaseServices, "Negative", "SELECT " + databaseServices.DMLService.Operators.Negative("{0}") + " FROM DUMMY" + MachineName, 1, -1);
AssertValue(databaseServices, "Negative", "SELECT " + databaseServices.DMLService.Operators.Negative("{0}") + " FROM DUMMY" + MachineName, -1.5m, 1.5m);
AssertValue(databaseServices, "Negative", "SELECT " + databaseServices.DMLService.Operators.Negative("{0}") + " FROM DUMMY" + MachineName, 1.5m, -1.5m);
}
public void TestParameterPrefix(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
var sqlExecutor = new SQLExecutor(databaseServices);
string sql = string.Format("SELECT VAL FROM DUMMY" + MachineName + " WHERE ID = {0}", sqlExecutor.GetParameterName(0, typeof(int)));
int value = sqlExecutor.ExecuteScalar(sql, 1).RuntimeValue <int>();
Assert.AreEqual(1, value, "ParameterPrefix didn't work as expected. SQL: " + sql);
}
public void TestBinaryDataDefaultValue(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
var sqlExecutor = new SQLExecutor(databaseServices);
IDMLDefaultValues dmlDefaultValues = databaseServices.DMLService.DefaultValues;
string sql = "SELECT " + dmlDefaultValues.BinaryData + " o1 FROM DUMMY" + MachineName;
byte[] result = sqlExecutor.ExecuteScalar(sql).RuntimeValue <byte[]>();
AssertEqual(0, (result ?? new byte[0]).Length, string.Format(errorMessageFormat, "Null", sql));
}
public void BusyPrivateTransactionPoolCount(DatabaseProviderTestCase tc)
{
var services = tc.Services;
WithTransactionManager(services.TransactionService.CreateTransactionManager(), (tm) => {
int initialCount = tm.BusyTransactionCount;
IDbTransaction privateTrans1 = tm.GetCommitableTransaction();
Assert.IsTrue(tm.BusyTransactionCount == (initialCount + 1));
});
}
public void GetRequestTransaction(DatabaseProviderTestCase tc)
{
var services = tc.Services;
WithTransactionManager(services.TransactionService.CreateTransactionManager(), (tm) => {
IDbTransaction trans1 = tm.GetRequestTransaction();
IDbTransaction trans2 = tm.GetRequestTransaction();
Assert.AreEqual(trans1, trans2);
});
}
public void TestEqual(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
AssertValue(databaseServices, "Equal", "SELECT PERSONID FROM PERSON" + MachineName + " WHERE " + databaseServices.DMLService.Operators.Equal("NAME", "{0}"), Person.DaveLauper.PersonId, Person.DaveLauper.Name);
AssertValue(databaseServices, "Equal", "SELECT PERSONID FROM PERSON" + MachineName + " WHERE " + databaseServices.DMLService.Operators.Equal("AGE", "{0}"), Person.DaveLauper.PersonId, Person.DaveLauper.Age);
AssertValue(databaseServices, "Equal", "SELECT PERSONID FROM PERSON" + MachineName + " WHERE " + databaseServices.DMLService.Operators.Equal("WEIGHT", "{0}"), Person.DaveLauper.PersonId, Person.DaveLauper.Weight);
AssertValue(databaseServices, "Equal", "SELECT PERSONID FROM PERSON" + MachineName + " WHERE " + databaseServices.DMLService.Operators.Equal("DEAD", "{0}"), Person.DaveLauper.PersonId, Person.DaveLauper.Dead);
AssertValue(databaseServices, "Equal", "SELECT PERSONID FROM PERSON" + MachineName + " WHERE " + databaseServices.DMLService.Operators.Equal("LASTLOGIN", "{0}"), Person.DaveLauper.PersonId, Person.DaveLauper.LastLogin);
}
public void TestCount(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
AssertValues(databaseServices, databaseServices.DMLService.AggregateFunctions.Count("PERSONID"), 3);
AssertValues(databaseServices, databaseServices.DMLService.AggregateFunctions.Count("NAME"), 3);
AssertValues(databaseServices, databaseServices.DMLService.AggregateFunctions.Count("AGE"), 2);
AssertValues(databaseServices, databaseServices.DMLService.AggregateFunctions.Count("WEIGHT"), 2);
AssertValues(databaseServices, databaseServices.DMLService.AggregateFunctions.Count("DEAD"), 1);
AssertValues(databaseServices, databaseServices.DMLService.AggregateFunctions.Count("LASTLOGIN"), 2);
}
public void TestListTableSourcesFindAllExpectedTableSources(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
IDatabaseInfo db = databaseServices.ObjectFactory.CreateDatabaseInfo(GetDatabaseIdentifier(databaseServices));
IEnumerable <ITableSourceInfo> tableSources = databaseServices.IntrospectionService.ListTableSourcesWithoutFilter(db);
foreach (var tableSourceName in bootstrappedTableName)
{
Assert.IsNotNull(tableSources.FirstOrDefault(ts => ts.Name.Equals(tableSourceName, StringComparison.InvariantCultureIgnoreCase)), "Table source named '" + tableSourceName + "' not found in the database");
}
}
public void CheckDateTypes(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
var executionService = databaseServices.ExecutionService;
DbType[] dateTypes = new DbType[] { DbType.Date, DbType.DateTime, DbType.Time };
foreach (DbType dateType in dateTypes)
{
Assert.IsTrue(executionService.IsDateType(dateType));
}
}
public void GetConsecutiveTransactionsUsingPrivate(DatabaseProviderTestCase tc)
{
var services = tc.Services;
WithTransactionManager(services.TransactionService.CreateTransactionManager(), (tm) => {
IDbTransaction trans1 = tm.GetReadOnlyTransaction();
tm.ReleaseTransaction(trans1);
IDbTransaction trans2 = tm.GetCommitableTransaction();
Assert.AreNotEqual(trans1, trans2, "Transactions must be different");
});
}
public void TestOr(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
string nameEquals = databaseServices.DMLService.Operators.Equal("NAME", "{0}");
string ageEquals = databaseServices.DMLService.Operators.Equal("AGE", "{1}");
AssertValue(databaseServices, "Or", "SELECT COUNT(*) FROM PERSON" + MachineName + " WHERE " + databaseServices.DMLService.Operators.Or(nameEquals, ageEquals), 1, Person.DaveLauper.Name, Person.DaveLauper.Age);
AssertValue(databaseServices, "Or", "SELECT COUNT(*) FROM PERSON" + MachineName + " WHERE " + databaseServices.DMLService.Operators.Or(nameEquals, ageEquals), 2, Person.DaveLauper.Name, Person.JohnOps.Age);
AssertValue(databaseServices, "Or", "SELECT COUNT(*) FROM PERSON" + MachineName + " WHERE " + databaseServices.DMLService.Operators.Or(nameEquals, ageEquals), 2, Person.JohnOps.Name, Person.DaveLauper.Age);
AssertValue(databaseServices, "Or", "SELECT COUNT(*) FROM PERSON" + MachineName + " WHERE " + databaseServices.DMLService.Operators.Or(nameEquals, ageEquals), 1, Person.JohnOps.Name, Person.JohnOps.Age);
}
public void TestLike(DatabaseProviderTestCase tc)
{
var databaseServices = tc.Services;
AssertValue(databaseServices, "Like", "SELECT COUNT(*) FROM PERSON" + MachineName + " WHERE " + databaseServices.DMLService.Operators.Like("NAME", "{0}"), 1, "DaveLauper");
AssertValue(databaseServices, "Like", "SELECT COUNT(*) FROM PERSON" + MachineName + " WHERE " + databaseServices.DMLService.Operators.Like("NAME", "{0}"), 0, "Dave");
AssertValue(databaseServices, "Like", "SELECT COUNT(*) FROM PERSON" + MachineName + " WHERE " + databaseServices.DMLService.Operators.Like("NAME", "{0}"), 1, "Dave%");
AssertValue(databaseServices, "Like", "SELECT COUNT(*) FROM PERSON" + MachineName + " WHERE " + databaseServices.DMLService.Operators.Like("NAME", "{0}"), 0, "Lauper");
AssertValue(databaseServices, "Like", "SELECT COUNT(*) FROM PERSON" + MachineName + " WHERE " + databaseServices.DMLService.Operators.Like("NAME", "{0}"), 1, "%Lauper");
AssertValue(databaseServices, "Like", "SELECT COUNT(*) FROM PERSON" + MachineName + " WHERE " + databaseServices.DMLService.Operators.Like("NAME", "{0}"), 3, "%");
}
