public void DbResultToSampleObjectAllowMissing()
{
const string mandatoryField = "Mandatory";
const int expectedMandatoryValue = 890;
{
DataTable dt = DatasetGenerator.CreateNewBasicDataTable(
new string[] { mandatoryField },
new Type[] { typeof(int) });
using (IDataReader dr = DatasetGenerator.CreateBasicDataReader(dt, expectedMandatoryValue))
{
dr.Read();
SampleObject obj = new SampleObject();
DbAutoFillHelper.FillObjectFromDataReader(dr, obj);
Assert.AreEqual(expectedMandatoryValue, obj.Mandatory);
}
}
{
DataTable dt = DatasetGenerator.CreateNewBasicDataTable(new string[] { }, new Type[] { });
using (IDataReader dr = DatasetGenerator.CreateBasicDataReader(dt, new object[] { }))
{
dr.Read();
SampleObject obj = new SampleObject();
Assert.ThrowsException <MissingFieldException>(() => { DbAutoFillHelper.FillObjectFromDataReader(dr, obj); });
}
}
}
public void DbParametersFromComplexObject()
{
const string expectedNameInName = "p_NameIN_IN";
const string expectedToDbUuidName = "p_ToDbUuid";
const string expectedNameINValue = "ComplexObject";
const string expectedAliasedFieldName = "p_ALittleTest";
const int expectedToDbUuidValue = 5;
ComplexObject obj = new ComplexObject
{
NameIN = expectedNameINValue,
ToDbUuid = expectedToDbUuidValue,
FromDbId = 66,
Aliased = true
};
DbAutoFillHelper.FillDbParametersFromObject(command, obj);
Assert.AreEqual(expectedNameInName, command.Parameters[expectedNameInName].ParameterName);
Assert.AreEqual(expectedNameINValue, command.Parameters[expectedNameInName].Value);
Assert.AreEqual(expectedToDbUuidName, command.Parameters[expectedToDbUuidName].ParameterName);
Assert.AreEqual(expectedToDbUuidValue, command.Parameters[expectedToDbUuidName].Value);
Assert.AreEqual(expectedAliasedFieldName, command.Parameters[expectedAliasedFieldName].ParameterName);
Assert.ThrowsException <IndexOutOfRangeException>(() => { string n = command.Parameters["FromDbId"].ParameterName; });
Assert.ThrowsException <IndexOutOfRangeException>(() => { string n = command.Parameters["Unsettable"].ParameterName; });
}
public void SetParametersFromObject_StructuredGood_Null_Test()
{
DbAutoFillHelper.AddParametersFromObjectMembers(_command, _dvco);
Assert.AreEqual(_command.Parameters.Count, 1);
Assert.IsTrue(((INullable)_command.Parameters[OBJECT_MYSTRUCTUREDFIELD_NAME].SqlValue).IsNull);
}
public void Advanced_SetParametersFromObject_ParametersSuffix_OnProperty_Test()
{
AdvancedAutoFillClass aafc = new AdvancedAutoFillClass();
DbAutoFillHelper.AddParametersFromObjectMembers(_command, aafc);
Assert.IsTrue(_command.Parameters.Contains(ADVANCED_PARAMETER_SUFFIX_PARAM_NAME));
}
public void Advanced_SetParametersFromObject_ParametersSuffix_OnClass_Test()
{
ClassWithSuffix cws = new ClassWithSuffix();
DbAutoFillHelper.AddParametersFromObjectMembers(_command, cws);
Assert.IsTrue(_command.Parameters.Contains(ADVANCED_PARAMETER_SUFFIX_PARAM_NAME));
}
public void SetParametersFromObject_GoodValues_Test()
{
DbAutoFillHelper.AddParametersFromObjectMembers(_command, _dvco);
Assert.AreEqual(_command.Parameters[DEFAULT_PARAMETER1_NAME].Value, DEFAULT_PARAMETER_1_VALUE);
Assert.AreEqual(_command.Parameters[DEFAULT_PARAMETER2_NAME].Value, DEFAULT_PARAMETER_2_VALUE);
Assert.AreEqual(_command.Parameters[DEFAULT_ToDB_PARAMETER_NAME].Value, DEFAULT_ToDBPARAMETER_VALUE);
}
public void GetDbAnonymousValue_Test()
{
DbAnonymousValue <int> value = new DbAnonymousValue <int>();
DbAutoFillHelper.FillObjectFromDataReader(value, _dataReader);
Assert.AreEqual(value.GetValue(), ANONYMOUS_SET_VALUE);
}
public void SetParameters_NamedDbAnonymousValue_Test()
{
DbAnonymousValue <int> val = new DbAnonymousValue <int>(ANONYMOUS_VALUE_ALIAS, ANONYMOUS_SET_VALUE);
DbAutoFillHelper.AddParameterWithValue(_command, val);
Assert.IsTrue(_command.Parameters.Contains(ANONYMOUS_VALUE_ALIAS));
Assert.AreEqual(_command.Parameters[ANONYMOUS_VALUE_ALIAS].Value, ANONYMOUS_SET_VALUE);
}
public void AddConcreteAnonymousValue()
{
DbAnonymousValue <string> expected = new DbAnonymousValue <string>("ParameterName", "AString");
DbAutoFillHelper.AddParameterWithValue(command, expected);
Assert.AreEqual(expected.Alias, command.Parameters[0].ParameterName);
Assert.AreEqual(expected.GetValue(), command.Parameters[0].Value);
}
public void Basic_SetParametersFromObject_PlainField_Test()
{
SecondObject so = new SecondObject();
DbAutoFillHelper.AddParametersFromObjectMembers(_command, so);
Assert.IsTrue(_command.Parameters.Contains(BASIC_PARAMETER_SECOND_OBJECT_NORMAL_FIELD));
Assert.IsTrue(_command.Parameters[BASIC_PARAMETER_SECOND_OBJECT_NORMAL_FIELD].Value.Equals(BASIC_PARAMETER_SECOND_OBJECT_NORMAL_FIELD_VALUE));
}
public void AddAnonymousValue()
{
const string expectedAlias = "Integer";
const int expectedValue = 50;
DbAutoFillHelper.AddParameterWithValue(command, expectedAlias, expectedValue, null);
Assert.AreEqual(expectedAlias, command.Parameters[0].ParameterName);
Assert.AreEqual(expectedValue, command.Parameters[0].Value);
}
public void SetParametersFromObject_GoodParameters_Test()
{
DbAutoFillHelper.AddParametersFromObjectMembers(_command, _dvco);
Assert.IsTrue(_command.Parameters.Contains(DEFAULT_PARAMETER1_NAME));
Assert.IsTrue(_command.Parameters.Contains(DEFAULT_PARAMETER2_NAME));
Assert.IsFalse(_command.Parameters.Contains(DEFAULT_HIDDEN_PARAMETER_NAME));
Assert.IsTrue(_command.Parameters.Contains(DEFAULT_ToDB_PARAMETER_NAME));
Assert.IsFalse(_command.Parameters.Contains(DEFAULT_NONE_PARAMETER_NAME));
Assert.IsFalse(_command.Parameters.Contains(DEFAULT_FROMDB_PARAMETER_NAME));
}
public void FillObjectFromDataReader_GoodValues_Test()
{
_dvco = new DefaultValuesClassObject();
DbAutoFillHelper.FillObjectFromDataReader(_dvco, _dataReader);
Assert.AreEqual(_dvco.Parameter1, DATAREADER_PARAMETER_1_VALUE);
Assert.AreEqual(_dvco.Parameter2, DATAREADER_PARAMETER_2_VALUE);
Assert.AreEqual(_dvco.FromDBParameter, DATAREADER_FROMDBPARAMETER_VALUE);
Assert.AreNotEqual(_dvco.NoneParameter, DATAREADER_NONEPARAMETER_VALUE);
Assert.AreNotEqual(_dvco.ToDBParameter, DATAREADER_ToDBPARAMETER_VALUE);
}
private void ReadResultsToDbResponse <TObjects>(IDbCommand command, DbResponse <TObjects> response)
where TObjects : new()
{
using (IDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
TObjects obj = new TObjects();
DbAutoFillHelper.FillObjectFromDataReader(reader, obj);
response.ResultSet.Add(obj);
}
}
}
public void Advanced_GetParametersFromDataReader_GoodValues_Test()
{
AdvancedAutoFillClass aafc = new AdvancedAutoFillClass();
IDataReader reader = CreateAdvancedDataReader();
reader.Read();
DbAutoFillHelper.FillObjectFromDataReader(aafc, reader);
Assert.AreEqual(aafc.AliasedParameter, ADVANCED_DATAREADER_ALIASED_VALUE);
Assert.AreEqual(aafc.DbTypeParameter, ADVANCED_DATAREADER_DBTYPE_VALUE);
Assert.AreEqual(aafc.DbTypeParameterDefault, ADVANCED_DATAREADER_DBTYPEDEFAULT_VALUE);
Assert.AreEqual(aafc.ParameterPrefixOverride, ADVANCED_DATAREADER_PREFIX_VALUE);
}
public void Advanced_SetParametersFromObject_GoodParameters_Test()
{
AdvancedAutoFillClass aafc = new AdvancedAutoFillClass();
DbAutoFillHelper.AddParametersFromObjectMembers(_command, aafc);
Assert.IsTrue(_command.Parameters.Count > 0);
Assert.IsTrue(_command.Parameters.Contains(ADVANCED_PARAMETER_ALIASED_PARAM_NAME));
Assert.IsTrue(_command.Parameters.Contains(ADVANCED_PARAMETER_ALLOWED_MISSING_PARAM_NAME));
Assert.IsTrue(_command.Parameters.Contains(ADVANCED_PARAMETER_DbTypeDTDefault_PARAM_NAME));
Assert.IsTrue(_command.Parameters.Contains(ADVANCED_PARAMETER_DbTypeDT_PARAM_NAME));
Assert.IsTrue(_command.Parameters.Contains(ADVANCED_PARAMETER_PREFIX_OVERRIDE_PARAM_NAME));
}
public void FillObjectFromDataReader_StructuredGood_Test()
{
DbAutoFillHelper.FillObjectFromDataReader(_dvco, _dataReader);
Assert.IsTrue(_dvco.MyStructuredField.Records.Count > 0);
MyGenericObject mgo = _dvco.FindGenericObjectFromId(int.Parse(OBJECT_FILL_ELEMENT1_ID));
Assert.IsNotNull(mgo);
Assert.AreEqual(mgo.name, OBJECT_FILL_ELEMENT1_NAME);
mgo = _dvco.FindGenericObjectFromId(int.Parse(OBJECT_FILL_ELEMENT2_ID));
Assert.IsNotNull(mgo);
Assert.AreEqual(mgo.name, OBJECT_FILL_ELEMENT2_NAME);
}
public void SetParametersFromObject_StructuredGood_NotNull_Test()
{
_dvco.MyStructuredField = new GenericSqlStructuredType();
_dvco.MyStructuredField.Add(new MyGenericObject()
{
id = OBJECT_SET_ELEMENT1_ID, name = OBJECT_SET_ELEMENT1_NAME
});
_dvco.MyStructuredField.Add(new MyGenericObject()
{
id = OBJECT_SET_ELEMENT2_ID, name = OBJECT_SET_ELEMENT2_NAME
});
DbAutoFillHelper.AddParametersFromObjectMembers(_command, _dvco);
Assert.IsTrue(_command.Parameters.Contains(OBJECT_MYSTRUCTUREDFIELD_NAME));
Assert.IsTrue(_command.Parameters[OBJECT_MYSTRUCTUREDFIELD_NAME].SqlDbType == SqlDbType.Structured);
}
public void DbParametersFromBasicObject()
{
const int expectedInt = 11;
const string expectedString = "HollyMolly";
const string expectedIntName = "IntField";
const string expectedStringProperty = "StringProperty";
BasicObject obj = new BasicObject
{
IntField = expectedInt,
StringProperty = expectedString
};
DbAutoFillHelper.FillDbParametersFromObject(command, obj);
Assert.AreEqual(obj.IntField, command.Parameters[expectedIntName].Value);
Assert.AreEqual(obj.StringProperty, command.Parameters[expectedStringProperty].Value);
}
public void DbResultsToBasicObject()
{
const string expectedStringValue = "String";
const int expectedIntValue = 76;
const string stringPropName = "StringProperty";
const string intPropName = "IntField";
DataTable dt = DatasetGenerator.CreateNewBasicDataTable(
new string[] { stringPropName, intPropName },
new Type[] { typeof(string), typeof(int) });
using (IDataReader dr = DatasetGenerator.CreateBasicDataReader(dt, expectedStringValue, expectedIntValue))
{
dr.Read();
BasicObject obj = new BasicObject();
DbAutoFillHelper.FillObjectFromDataReader(dr, obj);
Assert.AreEqual(obj.StringProperty, expectedStringValue);
Assert.AreEqual(obj.IntField, expectedIntValue);
}
}
public void DbResultToComplexObject()
{
const string nameINField = "NameIN";
const string toDbUuidField = "ToDbUuid";
const string fromDbIdField = "FromDbId";
const string expectedAliasedColumnName = "ALittleTest";
const string expectedNameINValue = "ComplexObject";
const int unexpectedToDbUuidValue = 23;
const int expectedFromDbUuid = 3;
const int expectedToDbUuidValue = -19;
const bool expectedAliaseColumnValue = true;
DataTable dt = DatasetGenerator.CreateNewBasicDataTable(
new string[] { nameINField, toDbUuidField, fromDbIdField, expectedAliasedColumnName },
new Type[] { typeof(string), typeof(int), typeof(int), typeof(string) });
using (IDataReader dr = DatasetGenerator.CreateBasicDataReader(dt,
expectedNameINValue,
unexpectedToDbUuidValue,
expectedFromDbUuid,
expectedAliaseColumnValue))
{
dr.Read();
ComplexObject obj = new ComplexObject();
obj.ToDbUuid = expectedToDbUuidValue;
DbAutoFillHelper.FillObjectFromDataReader(dr, obj);
Assert.AreEqual(expectedNameINValue, obj.NameIN);
Assert.AreNotEqual(unexpectedToDbUuidValue, obj.ToDbUuid);
Assert.AreEqual(expectedToDbUuidValue, obj.ToDbUuid);
Assert.AreEqual(expectedFromDbUuid, obj.FromDbId);
Assert.AreEqual(expectedAliaseColumnValue, obj.Aliased);
}
}
private void AddParametersWithValueToCommand(IDbCommand command, params object[] parameters)
{
if (parameters == null || parameters.Length == 0)
{
return;
}
foreach (object parameter in parameters)
{
if (parameter != null && false == (parameter is DBNull))
{
IDbAnonymousValue anonymousParam = parameter as IDbAnonymousValue;
if (anonymousParam != null)
{
DbAutoFillHelper.AddParameterWithValue(command, anonymousParam.Alias, anonymousParam.GetValue(), null);
}
else
{
DbAutoFillHelper.FillDbParametersFromObject(command, parameter);
}
}
}
}
public void SetParameters_NamedAnonymous_Raw_Test()
{
DbAutoFillHelper.AddParameterWithValue(_command, ANONYMOUS_VALUE_ALIAS, ANONYMOUS_SET_VALUE, null);
Assert.IsTrue(_command.Parameters.Contains(ANONYMOUS_VALUE_ALIAS));
Assert.AreEqual(_command.Parameters[ANONYMOUS_VALUE_ALIAS].Value, ANONYMOUS_SET_VALUE);
}
