Components/Binder/Castle.Components.Binder.Tests/DataReaderIntegrationTestCase.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.Components.Binder.Tests
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Data;
  20
  21         using Nullables;
  22
  23         using NUnit.Framework;
  24
  25         [TestFixture]
  26         public class DataReaderIntegrationTestCase
  27         {
  28                 [Test]
  29                 public void EmptyReader()
  30                 {
  31                         ArrayList data = new ArrayList();
  32
  33                         MockDataReader reader = new MockDataReader(data, new string[] { "name", "address"});
  34
  35                         DataBinder binder = new DataBinder();
  36
  37                         Contact[] contacts = (Contact[]) binder.BindObject(typeof(Contact[]), "cont", new DataReaderTreeBuilder().BuildSourceNode(reader, "cont"));
  38
  39                         Assert.IsNotNull(contacts);
  40                         Assert.AreEqual(0, contacts.Length);
  41                 }
  42
  43                 [Test]
  44                 public void SingleRow()
  45                 {
  46                         ArrayList data = new ArrayList();
  47
  48                         data.Add( new object[] { "hammett", "r pereira leite 44" } );
  49
  50                         MockDataReader reader = new MockDataReader(data, new string[] { "name", "address"}, typeof(String), typeof(String));
  51
  52                         DataBinder binder = new DataBinder();
  53
  54                         Contact[] contacts = (Contact[]) binder.BindObject(typeof(Contact[]), "cont", new DataReaderTreeBuilder().BuildSourceNode(reader, "cont"));
  55
  56                         Assert.IsNotNull(contacts);
  57                         Assert.AreEqual(1, contacts.Length);
  58                         Assert.AreEqual("hammett", contacts[0].Name);
  59                         Assert.AreEqual("r pereira leite 44", contacts[0].Address);
  60                 }
  61
  62                 [Test]
  63                 public void UsingTypeConverter()
  64                 {
  65                         ArrayList data = new ArrayList();
  66
  67                         data.Add( new object[] { "hammett", "r pereira leite 44", new DateTime(2006,7,16) } );
  68
  69                         MockDataReader reader = new MockDataReader(data, new string[] { "name", "address", "dob" }, typeof(String), typeof(String), typeof(DateTime));
  70
  71                         DataBinder binder = new DataBinder();
  72
  73                         Contact[] contacts = (Contact[]) binder.BindObject(typeof(Contact[]), "cont", new DataReaderTreeBuilder().BuildSourceNode(reader, "cont"));
  74
  75                         Assert.IsNotNull(contacts);
  76                         Assert.AreEqual(1, contacts.Length);
  77                         Assert.AreEqual("hammett", contacts[0].Name);
  78                         Assert.AreEqual("r pereira leite 44", contacts[0].Address);
  79                         Assert.IsTrue(contacts[0].DOB.HasValue);
  80                 }
  81
  82                 [Test]
  83                 public void TwoRows()
  84                 {
  85                         ArrayList data = new ArrayList();
  86
  87                         data.Add( new object[] { 26, "hammett", "r pereira leite 44" } );
  88                         data.Add( new object[] { 27, "his girl", "barao bananal 100" } );
  89
  90                         MockDataReader reader = new MockDataReader(data, new string[] { "age", "name", "address"}, typeof(int), typeof(String), typeof(String));
  91
  92                         DataBinder binder = new DataBinder();
  93
  94                         Contact[] contacts = (Contact[]) binder.BindObject(typeof(Contact[]), "cont", new DataReaderTreeBuilder().BuildSourceNode(reader, "cont"));
  95
  96                         Assert.IsNotNull(contacts);
  97                         Assert.AreEqual(2, contacts.Length);
  98
  99                         Assert.AreEqual(26, contacts[0].Age);
 100                         Assert.AreEqual("hammett", contacts[0].Name);
 101                         Assert.AreEqual("r pereira leite 44", contacts[0].Address);
 102
 103                         Assert.AreEqual(27, contacts[1].Age);
 104                         Assert.AreEqual("his girl", contacts[1].Name);
 105                         Assert.AreEqual("barao bananal 100", contacts[1].Address);
 106                 }
 107
 108                 [Test]
 109                 public void UsingTranslator()
 110                 {
 111                         ArrayList data = new ArrayList();
 112
 113                         data.Add( new object[] { 26, "hammett", "r pereira leite 44" } );
 114                         data.Add( new object[] { 27, "his girl", "barao bananal 100" } );
 115
 116                         MockDataReader reader = new MockDataReader(data, new string[] { "idade", "nome", "endereco"}, typeof(int), typeof(String), typeof(String));
 117
 118                         DataBinder binder = new DataBinder();
 119                         binder.Translator = new EnglishToPortugueseTranslator();
 120
 121                         Contact[] contacts = (Contact[]) binder.BindObject(typeof(Contact[]), "cont", new DataReaderTreeBuilder().BuildSourceNode(reader, "cont"));
 122
 123                         Assert.IsNotNull(contacts);
 124                         Assert.AreEqual(2, contacts.Length);
 125
 126                         Assert.AreEqual(26, contacts[0].Age);
 127                         Assert.AreEqual("hammett", contacts[0].Name);
 128                         Assert.AreEqual("r pereira leite 44", contacts[0].Address);
 129
 130                         Assert.AreEqual(27, contacts[1].Age);
 131                         Assert.AreEqual("his girl", contacts[1].Name);
 132                         Assert.AreEqual("barao bananal 100", contacts[1].Address);
 133                 }
 134         }
 135
 136         public class EnglishToPortugueseTranslator : IBinderTranslator
 137         {
 138                 public String Translate(Type instanceType, String paramName)
 139                 {
 140                         if (paramName == "Age")
 141                         {
 142                                 return "idade";
 143                         }
 144                         else if (paramName == "Name")
 145                         {
 146                                 return "nome";
 147                         }
 148                         else if (paramName == "Address")
 149                         {
 150                                 return "endereco";
 151                         }
 152
 153                         return null;
 154                 }
 155         }
 156
 157         public class MockDataReader : IDataReader
 158         {
 159                 private readonly IList source;
 160                 private readonly string[] fields;
 161                 private readonly Type[] types;
 162                 private int index = -1;
 163
 164                 public MockDataReader(IList source, String[] fields, params Type[] types)
 165                 {
 166                         this.source = source;
 167                         this.fields = fields;
 168                         this.types = types;
 169                 }
 170
 171                 #region IDataReader
 172
 173                 public void Close()
 174                 {
 175                         throw new NotImplementedException();
 176                 }
 177
 178                 public bool NextResult()
 179                 {
 180                         throw new NotImplementedException();
 181                 }
 182
 183                 public bool Read()
 184                 {
 185                         if (index + 1 < source.Count)
 186                         {
 187                                 index++;
 188                                 return true;
 189                         }
 190
 191                         return false;
 192                 }
 193
 194                 public DataTable GetSchemaTable()
 195                 {
 196                         throw new NotImplementedException();
 197                 }
 198
 199                 public int Depth
 200                 {
 201                         get { throw new NotImplementedException(); }
 202                 }
 203
 204                 public bool IsClosed
 205                 {
 206                         get { throw new NotImplementedException(); }
 207                 }
 208
 209                 public int RecordsAffected
 210                 {
 211                         get { throw new NotImplementedException(); }
 212                 }
 213
 214                 #endregion
 215
 216                 #region IDisposable
 217
 218                 public void Dispose()
 219                 {
 220                         throw new NotImplementedException();
 221                 }
 222
 223                 #endregion
 224
 225                 #region IDataRecord
 226
 227                 public string GetName(int i)
 228                 {
 229                         return fields[i];
 230                 }
 231
 232                 public string GetDataTypeName(int i)
 233                 {
 234                         throw new NotImplementedException();
 235                 }
 236
 237                 public Type GetFieldType(int i)
 238                 {
 239                         return types[i];
 240                 }
 241
 242                 public object GetValue(int i)
 243                 {
 244                         return ((object[]) source[index])[i];
 245                 }
 246
 247                 public int GetValues(object[] values)
 248                 {
 249                         throw new NotImplementedException();
 250                 }
 251
 252                 public int GetOrdinal(string name)
 253                 {
 254                         return Array.IndexOf(fields, name.ToLower());
 255                 }
 256
 257                 public bool GetBoolean(int i)
 258                 {
 259                         return Convert.ToBoolean( GetValue(i) );
 260                 }
 261
 262                 public byte GetByte(int i)
 263                 {
 264                         return Convert.ToByte( GetValue(i) );
 265                 }
 266
 267                 public long GetBytes(int i, long fieldOffset, byte[] buffer, int bufferoffset, int length)
 268                 {
 269                         throw new NotImplementedException();
 270                 }
 271
 272                 public char GetChar(int i)
 273                 {
 274                         return Convert.ToChar( GetValue(i) );
 275                 }
 276
 277                 public long GetChars(int i, long fieldoffset, char[] buffer, int bufferoffset, int length)
 278                 {
 279                         throw new NotImplementedException();
 280                 }
 281
 282                 public Guid GetGuid(int i)
 283                 {
 284                         throw new NotImplementedException();
 285                 }
 286
 287                 public short GetInt16(int i)
 288                 {
 289                         return Convert.ToInt16( GetValue(i) );
 290                 }
 291
 292                 public int GetInt32(int i)
 293                 {
 294                         return Convert.ToInt32( GetValue(i) );
 295                 }
 296
 297                 public long GetInt64(int i)
 298                 {
 299                         return Convert.ToInt64( GetValue(i) );
 300                 }
 301
 302                 public float GetFloat(int i)
 303                 {
 304                         return Convert.ToSingle( GetValue(i) );
 305                 }
 306
 307                 public double GetDouble(int i)
 308                 {
 309                         return Convert.ToDouble( GetValue(i) );
 310                 }
 311
 312                 public string GetString(int i)
 313                 {
 314                         return Convert.ToString( GetValue(i) );
 315                 }
 316
 317                 public decimal GetDecimal(int i)
 318                 {
 319                         return Convert.ToDecimal( GetValue(i) );
 320                 }
 321
 322                 public DateTime GetDateTime(int i)
 323                 {
 324                         return Convert.ToDateTime( GetValue(i) );
 325                 }
 326
 327                 public IDataReader GetData(int i)
 328                 {
 329                         throw new NotImplementedException();
 330                 }
 331
 332                 public bool IsDBNull(int i)
 333                 {
 334                         return GetValue(i) == null;
 335                 }
 336
 337                 public int FieldCount
 338                 {
 339                         get { return fields.Length; }
 340                 }
 341
 342                 public object this[int i]
 343                 {
 344                         get { throw new NotImplementedException(); }
 345                 }
 346
 347                 public object this[string name]
 348                 {
 349                         get { throw new NotImplementedException(); }
 350                 }
 351
 352                 #endregion
 353         }
 354
 355         public class Contact
 356         {
 357                 private int age;
 358                 private String name, address;
 359                 private NullableDateTime dob;
 360
 361                 public int Age
 362                 {
 363                         get { return age; }
 364                         set { age = value; }
 365                 }
 366
 367                 public string Name
 368                 {
 369                         get { return name; }
 370                         set { name = value; }
 371                 }
 372
 373                 public string Address
 374                 {
 375                         get { return address; }
 376                         set { address = value; }
 377                 }
 378
 379                 public NullableDateTime DOB
 380                 {
 381                         get { return dob; }
 382                         set { dob = value; }
 383                 }
 384         }
 385 }