Mercurial > pub > bltoolkit
diff UnitTests/CS/DataAccess/DictionaryTest.cs @ 0:f990fcb411a9
Копия текущей версии из github
author | cin |
---|---|
date | Thu, 27 Mar 2014 21:46:09 +0400 |
parents | |
children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/UnitTests/CS/DataAccess/DictionaryTest.cs Thu Mar 27 21:46:09 2014 +0400 @@ -0,0 +1,562 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +using NUnit.Framework; + +using BLToolkit.Common; +using BLToolkit.DataAccess; +using BLToolkit.TypeBuilder; +using BLToolkit.Mapping; + +namespace DataAccess +{ + [TestFixture] + public class DictionaryTest + { + public class Person + { + [MapField("PersonID"), PrimaryKey] + public int ID; + public string LastName; + public string FirstName; + public string MiddleName; + } + + public class Derived : Person + { + [MapIgnore] + public string Ignore; + public DateTime Date; + } + + // Same as Person, but does not have any primary keys. + public class PersonNoPK + { + [MapField("PersonID")] + public int ID; + public string LastName; + public string FirstName; + public string MiddleName; + } + + // Same as Person, but has a number of primary keys. + public class PersonMultiPK + { + [MapField("PersonID"), PrimaryKey] + public int ID; + [PrimaryKey(22)] + public string LastName; + public string FirstName; + public string MiddleName; + } + + [ObjectType(typeof(Person))] + public abstract class TestAccessor : DataAccessor + { + private const string TEST_QUERY = "SELECT * FROM Person WHERE PersonID < 3"; + + [SqlQuery("SELECT * FROM Person")] + [Index("ID")] + public abstract Hashtable SelectAll1(); + + [NoInstance] + public abstract Hashtable Persons + { + [SqlQuery("SELECT * FROM Person")] + [Index("ID")] + get; + } + + [SqlQuery(TEST_QUERY)] + [Index("@PersonID", "LastName")] + public abstract Hashtable SelectAll2(); + + [SqlQuery(TEST_QUERY)] + [Index("@PersonID")] + [ScalarFieldName("FirstName")] + [ObjectType(typeof(string))] + public abstract Hashtable SelectAll3(); + + [SqlQuery(TEST_QUERY)] + [Index("PersonID", "LastName")] + [ScalarFieldName("FirstName")] + [ObjectType(typeof(string))] + public abstract Hashtable SelectAll4(); + + [SqlQuery(TEST_QUERY)] + [Index("PersonID", "LastName")] + [ScalarFieldName(1)] + [ObjectType(typeof(string))] + public abstract Hashtable SelectAll5(); + + [SqlQuery(TEST_QUERY)] + [Index("PersonID", "LastName")] + [ScalarFieldName(1)] + [ObjectType(typeof(string))] + public abstract IDictionary SelectAllAsIDictionary(); + + // Primary Key(s) => scalar filed. This will fail, since + // we can not figure out both key type and scalar object type. + // Note that version with generics works just fine. + // + [SqlQuery(TEST_QUERY)] + [ScalarFieldName("FirstName"), ObjectType(typeof(string))] + public abstract Hashtable ScalarDictionaryByPK(); + + [SqlQuery(TEST_QUERY)] + [ObjectType(typeof(PersonNoPK))] + public abstract Hashtable Keyless(); + + [SqlQuery(TEST_QUERY)] + [ObjectType(typeof(PersonMultiPK))] + public abstract Hashtable MultiPK(); + + [SqlQuery(TEST_QUERY)] + [ObjectType(typeof(PersonMultiPK))] + public abstract void MultiPKReturnVoid([Destination] Hashtable dictionary); + + [SqlQuery(TEST_QUERY)] + public abstract Hashtable DictionaryByPK(); + + [SqlQuery(TEST_QUERY)] + [Index("@PersonID")] + public abstract Hashtable DictionaryByIndex(); + + [SqlQuery(TEST_QUERY)] + [Index(0, 1)] + public abstract Hashtable DictionaryByMapIndex(); + + [SqlQuery(TEST_QUERY)] + [Index(0, 1)] + public abstract IDictionary DictionaryByMapIndexWithDestination([Destination] Hashtable dictionary); + + [SqlQuery(TEST_QUERY)] + [Index(0), ScalarFieldName(1)] + public abstract void GenericsScalarDictionaryByIndexReturnVoid1([Destination] IDictionary<int, string> dictionary); + + [SqlQuery("SELECT * FROM Person")] + [Index(new string[] { "ID" })] + public abstract Dictionary<int, Person> SelectAllT1(); + + [SqlQuery("SELECT * FROM Person")] + [Index("@PersonID", "LastName")] + public abstract Dictionary<CompoundValue, Person> SelectAllT2(); + + [SqlQuery("SELECT * FROM Person")] + [Index("@PersonID")] + [ScalarFieldName("FirstName")] + public abstract Dictionary<int, string> SelectAllT3(); + + [SqlQuery("SELECT * FROM Person")] + [Index("PersonID", "LastName")] + [ScalarFieldName("FirstName")] + public abstract Dictionary<CompoundValue, string> SelectAllT4(); + + [SqlQuery("SELECT * FROM Person")] + [Index("PersonID", "LastName")] + [ScalarFieldName(1)] + public abstract Dictionary<CompoundValue, string> SelectAllT5(); + + [SqlQuery("SELECT * FROM Person")] + [Index("PersonID", "LastName")] + [ScalarFieldName(1)] + public abstract IDictionary<CompoundValue, string> SelectAllAsIDictionaryT(); + + [SqlQuery(TEST_QUERY)] + [ScalarFieldName("FirstName")] + public abstract Dictionary<object, string> GenericsScalarDictionaryByPK(); + + [SqlQuery(TEST_QUERY)] + [ScalarFieldName(1)] // Index from Db table Person, not type Person! + public abstract Dictionary<int, string> GenericsScalarDictionaryByPK2(); + + [SqlQuery(TEST_QUERY)] + [Index(0), ScalarFieldName(1)] + public abstract Dictionary<int, string> GenericsScalarDictionaryByIndex(); + + [SqlQuery(TEST_QUERY)] + [Index(0), ScalarFieldName(1)] + public abstract void GenericsScalarDictionaryByIndexReturnVoid([Destination] IDictionary<int, string> dictionary); + + [SqlQuery(TEST_QUERY)] + [Index(0, 1), ScalarFieldName(1)] + public abstract Dictionary<CompoundValue, string> GenericsScalarDictionaryByMapIndex(); + + [SqlQuery(TEST_QUERY)] + [Index(0)] + public abstract Dictionary<int, PersonNoPK> GenericsScalarDictionaryByPKWithCustomType(); + + [SqlQuery(TEST_QUERY)] + [ObjectType(typeof(Person))] + public abstract Dictionary<int, object> GenericsScalarDictionaryByPKWithObjectType(); + +#if SQLITE || SQLCE + [SqlQuery("SELECT * FROM Person")] +#else + [ActionName("SelectAll")] +#endif + [Index("ID")] + public abstract Dictionary<uint, Person> SelectAllT7(); + +#if SQLITE || SQLCE + [SqlQuery("SELECT * FROM Person")] +#else + [ActionName("SelectAll")] +#endif + public abstract Dictionary<long, Person> SelectAllT8(); + +#if SQLITE || SQLCE + [SqlQuery("SELECT * FROM Person")] +#else + [SprocName("Person_SelectAll")] +#endif + public abstract Dictionary<long, Derived> SelectAllDerived(); + +#if SQLITE || SQLCE + [SqlQuery("SELECT * FROM Person")] +#else + [SprocName("Person_SelectAll")] +#endif + public abstract Dictionary<CompoundValue, PersonMultiPK> SelectAllT9(); + } + + private TestAccessor _da; + +#if ORACLE + private const decimal _id = 1m; +#elif SQLITE + private const long _id = 1; +#else + private const int _id = 1; +#endif + + public DictionaryTest() + { + _da = (TestAccessor)DataAccessor.CreateInstance(typeof(TestAccessor)); + } + + [Test] + public void Test() + { + Hashtable dic1 = _da.SelectAll1(); + Assert.AreEqual("John", ((Person)dic1[1]).FirstName); + + Hashtable dic2 = _da.SelectAll2(); + Assert.AreEqual("John", ((Person)dic2[new CompoundValue(_id, "Pupkin")]).FirstName); + + Hashtable dic3 = _da.SelectAll3(); + Assert.AreEqual("John", dic3[_id]); + + Hashtable dic4 = _da.SelectAll4(); + Assert.AreEqual("John", dic4[new CompoundValue(_id, "Pupkin")]); + + Hashtable dic5 = _da.SelectAll5(); + Assert.AreEqual("John", dic5[new CompoundValue(_id, "Pupkin")]); + + IDictionary dic6 = _da.SelectAllAsIDictionary(); + Assert.AreEqual("John", dic6[new CompoundValue(_id, "Pupkin")]); + + Dictionary<int, Person> dict1 = _da.SelectAllT1(); + Assert.AreEqual("John", dict1[1].FirstName); + + Dictionary<CompoundValue, Person> dict2 = _da.SelectAllT2(); + Assert.AreEqual("John", dict2[new CompoundValue(_id, "Pupkin")].FirstName); + + Dictionary<int, string> dict3 = _da.SelectAllT3(); + Assert.AreEqual("John", dict3[1]); + + Dictionary<CompoundValue, string> dict4 = _da.SelectAllT4(); + Assert.AreEqual("John", dict4[new CompoundValue(_id, "Pupkin")]); + + Dictionary<CompoundValue, string> dict5 = _da.SelectAllT5(); + Assert.AreEqual("John", dict5[new CompoundValue(_id, "Pupkin")]); + + IDictionary<CompoundValue, string> dict6 = _da.SelectAllAsIDictionaryT(); + Assert.AreEqual("John", dict6[new CompoundValue(_id, "Pupkin")]); + } + + [Test] + public void AbstractGetterTest() + { + Hashtable dic = _da.Persons; + Assert.AreEqual("John", ((Person)dic[1]).FirstName); + } + + [Test, ExpectedException(typeof(DataAccessException))] + public void KeylessTest() + { + TestAccessor da = (TestAccessor)DataAccessor.CreateInstance(typeof(TestAccessor)); + + // Exception here: + // Index is not defined for the method 'TestAccessor.Keyless' + da.Keyless(); + } + + [Test] + public void DictionaryByPKTest() + { + TestAccessor da = (TestAccessor)DataAccessor.CreateInstance(typeof(TestAccessor)); + + Hashtable persons = da.DictionaryByPK(); + + Assert.IsNotNull(persons); + Assert.IsTrue(persons.Count > 0); + Assert.IsNull(persons[-1]); + + Person actualValue = (Person)persons[1]; + Assert.IsNotNull(actualValue); + Assert.AreEqual("John", actualValue.FirstName); + } + + [Test] + public void DictionaryByIndexTest() + { + TestAccessor da = (TestAccessor)DataAccessor.CreateInstance(typeof(TestAccessor)); + + Hashtable persons = da.DictionaryByIndex(); + + Assert.IsNotNull(persons); + Assert.IsTrue(persons.Count > 0); + Assert.IsNull(persons[-1]); + + Person actualValue = (Person)persons[_id]; + Assert.IsNotNull(actualValue); + Assert.AreEqual("John", actualValue.FirstName); + } + + [Test] + public void DictionaryByMapIndexTest() + { + TestAccessor da = (TestAccessor)DataAccessor.CreateInstance(typeof(TestAccessor)); + + Hashtable persons = da.DictionaryByMapIndex(); + + Assert.IsNotNull(persons); + Assert.IsTrue(persons.Count > 0); + Assert.IsNull(persons[-1]); + + Person actualValue = (Person)persons[new CompoundValue(1, "Pupkin")]; + Assert.IsNotNull(actualValue); + Assert.AreEqual("John", actualValue.FirstName); + } + + [Test] + public void DictionaryByMapIndexTestWithDestination() + { + TestAccessor da = (TestAccessor)DataAccessor.CreateInstance(typeof(TestAccessor)); + + IDictionary persons = da.DictionaryByMapIndexWithDestination(new Hashtable()); + + Assert.IsNotNull(persons); + Assert.IsTrue(persons.Count > 0); + Assert.IsNull(persons[-1]); + + Person actualValue = (Person)persons[new CompoundValue(1, "Pupkin")]; + Assert.IsNotNull(actualValue); + Assert.AreEqual("John", actualValue.FirstName); + } + + [Test, ExpectedException(typeof(DataAccessException))] + public void ScalarDictionaryByPKTest() + { + TestAccessor da = (TestAccessor)DataAccessor.CreateInstance(typeof(TestAccessor)); + + // Exception here: + // Index is not defined for the method 'TestAccessor.ScalarDictionaryByPK' + da.ScalarDictionaryByPK(); + } + + [Test] + public void MultiPKTest() + { + TestAccessor da = (TestAccessor)DataAccessor.CreateInstance(typeof(TestAccessor)); + + Hashtable persons = da.MultiPK(); + + Assert.IsNotNull(persons); + Assert.IsTrue(persons.Count > 0); + Assert.IsNull(persons[new CompoundValue(-1, "NoSuchPerson")]); + + PersonMultiPK actualValue = (PersonMultiPK)persons[new CompoundValue(1, "Pupkin")]; + Assert.IsNotNull(actualValue); + Assert.AreEqual("John", actualValue.FirstName); + } + + [Test] + public void MultiPKTestReturnVoid() + { + TestAccessor da = (TestAccessor)DataAccessor.CreateInstance(typeof(TestAccessor)); + + Hashtable persons = new Hashtable(); + da.MultiPKReturnVoid(persons); + + Assert.IsNotNull(persons); + Assert.IsTrue(persons.Count > 0); + Assert.IsNull(persons[new CompoundValue(-1, "NoSuchPerson")]); + + PersonMultiPK actualValue = (PersonMultiPK)persons[new CompoundValue(1, "Pupkin")]; + Assert.IsNotNull(actualValue); + Assert.AreEqual("John", actualValue.FirstName); + } + + [Test] + public void GenericsScalarDictionaryByPKTest() + { + TestAccessor da = DataAccessor.CreateInstance<TestAccessor>(); + + Dictionary<object, string> persons = da.GenericsScalarDictionaryByPK(); + + Assert.IsNotNull(persons); + Assert.IsTrue(persons.Count > 0); + + string actualValue = persons[_id]; + Assert.IsNotNull(actualValue); + Assert.AreEqual("John", actualValue); + } + + [Test] + public void GenericsScalarDictionaryByPKTest2() + { + TestAccessor da = DataAccessor.CreateInstance<TestAccessor>(); + + Dictionary<int, string> persons = da.GenericsScalarDictionaryByPK2(); + + Assert.IsNotNull(persons); + Assert.IsTrue(persons.Count > 0); + + string actualValue = persons[1]; + Assert.IsNotNull(actualValue); + Assert.AreEqual("John", actualValue); + } + + [Test] + public void GenericsScalarDictionaryByIndexTest() + { + TestAccessor da = DataAccessor.CreateInstance<TestAccessor>(); + + Dictionary<int, string> persons = da.GenericsScalarDictionaryByIndex(); + + Assert.IsNotNull(persons); + Assert.IsTrue(persons.Count > 0); + + string actualValue = persons[1]; + Assert.IsNotNull(actualValue); + Assert.AreEqual("John", actualValue); + } + + [Test] + public void GenericsScalarDictionaryByIndexReturnVoidTest() + { + TestAccessor da = DataAccessor.CreateInstance<TestAccessor>(); + + IDictionary<int, string> persons = new Dictionary<int, string>(); + da.GenericsScalarDictionaryByIndexReturnVoid(persons); + + Assert.IsNotNull(persons); + Assert.IsTrue(persons.Count > 0); + + string actualValue = persons[1]; + Assert.IsNotNull(actualValue); + Assert.AreEqual("John", actualValue); + } + + [Test] + public void GenericsScalarDictionaryByMapIndexTest() + { + TestAccessor da = DataAccessor.CreateInstance<TestAccessor>(); + Dictionary<CompoundValue, string> persons = da.GenericsScalarDictionaryByMapIndex(); + + Assert.IsNotNull(persons); + Assert.IsTrue(persons.Count > 0); + + string actualValue = persons[new CompoundValue(_id, "John")]; + Assert.IsNotNull(actualValue); + Assert.AreEqual("John", actualValue); + } + + [Test] + public void GenericsScalarDictionaryByPKWithCustomTypeTest() + { + TestAccessor da = DataAccessor.CreateInstance<TestAccessor>(); + Dictionary<int, PersonNoPK> persons = da.GenericsScalarDictionaryByPKWithCustomType(); + + Assert.IsNotNull(persons); + Assert.IsTrue(persons.Count > 0); + + PersonNoPK actualValue = persons[1]; + Assert.IsNotNull(actualValue); + Assert.AreEqual("John", actualValue.FirstName); + } + + [Test] + public void GenericsScalarDictionaryByPKWithObjectTypeTest() + { + TestAccessor da = DataAccessor.CreateInstance<TestAccessor>(); + Dictionary<int, object> persons = da.GenericsScalarDictionaryByPKWithObjectType(); + + Assert.IsNotNull(persons); + Assert.IsTrue(persons.Count > 0); + + Person actualValue = (Person) persons[1]; + Assert.IsNotNull(actualValue); + Assert.AreEqual("John", actualValue.FirstName); + } + + [Test] + public void GenericsDictionaryMismatchKeyTypeTest() + { + TestAccessor da = DataAccessor.CreateInstance<TestAccessor>(); + Dictionary<uint, Person> persons = da.SelectAllT7(); + + Assert.IsNotNull(persons); + Assert.IsTrue(persons.Count > 0); + + Person actualValue = persons[1]; + Assert.IsNotNull(actualValue); + Assert.AreEqual("John", actualValue.FirstName); + } + + [Test] + public void GenericsDictionaryMismatchKeyTypeTest2() + { + TestAccessor da = DataAccessor.CreateInstance<TestAccessor>(); + Dictionary<long, Person> persons = da.SelectAllT8(); + + Assert.IsNotNull(persons); + Assert.IsTrue(persons.Count > 0); + + Person actualValue = persons[1]; + Assert.IsNotNull(actualValue); + Assert.AreEqual("John", actualValue.FirstName); + } + + [Test] + public void GenericsDictionaryMismatchKeyTypeWithHierarchyTest() + { + TestAccessor da = DataAccessor.CreateInstance<TestAccessor>(); + Dictionary<long, Derived> persons = da.SelectAllDerived(); + + Assert.IsNotNull(persons); + Assert.IsTrue(persons.Count > 0); + + Person actualValue = persons[1]; + Assert.IsNotNull(actualValue); + Assert.AreEqual("John", actualValue.FirstName); + } + + [Test] + public void GenericsDictionaryMismatchKeyTypeCompoundValueTest() + { + TestAccessor da = DataAccessor.CreateInstance<TestAccessor>(); + Dictionary<CompoundValue, PersonMultiPK> persons = da.SelectAllT9(); + + Assert.IsNotNull(persons); + Assert.IsTrue(persons.Count > 0); + + PersonMultiPK actualValue = persons[new CompoundValue(1, "Pupkin")]; + Assert.IsNotNull(actualValue); + Assert.AreEqual("John", actualValue.FirstName); + } + } +} \ No newline at end of file