mcs/class/System.Web/Test/System.Web.UI.WebControls/ObjectDataSourceTest.cs

   1 //
   2 // Tests for System.Web.UI.WebControls.FormView.cs
   3 //
   4 // Author:
   5 //      Merav Sudri (meravs@mainsoft.com)
   6 //
   7 //
   8 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 #if NET_2_0
  31
  32 using NUnit.Framework;
  33 using System;
  34 using System.Threading;
  35 using System.Data;
  36 using System.Data.Common;
  37 using System.IO;
  38 using System.Drawing;
  39 using System.Collections;
  40 using System.Globalization;
  41 using System.Web;
  42 using System.Web.UI;
  43 using System.Web.UI.WebControls;
  44 using MonoTests.SystemWeb.Framework;
  45 using MonoTests.stand_alone.WebHarness;
  46
  47
  48 namespace MonoTests.System.Web.UI.WebControls
  49 {
  50         public class  ObjectDataSourcePoker : ObjectDataSource
  51         {
  52                 public ObjectDataSourcePoker () // constructor
  53                 {
  54
  55                 TrackViewState ();
  56                 }
  57
  58                 public void DoRaiseDataSourceChangedEvent ()
  59                 {
  60                         base.RaiseDataSourceChangedEvent (new EventArgs ());
  61                 }
  62
  63                 public object SaveState ()
  64                 {
  65                  return SaveViewState ();
  66                 }
  67
  68                 public void LoadState (object o)
  69                 {
  70                   LoadViewState (o);
  71
  72                 }
  73
  74                 public StateBag StateBag
  75                 {
  76                  get { return base.ViewState; }
  77                 }
  78
  79                 public string Render ()
  80                 {
  81                         StringWriter sw = new StringWriter ();
  82                         HtmlTextWriter tw = new HtmlTextWriter (sw);
  83                         Render (tw);
  84                         return sw.ToString ();
  85                 }
  86
  87                 public void DoOnBubbleEvent (Object source, EventArgs e)
  88                 {
  89                         base.OnBubbleEvent (source, e);
  90                 }
  91
  92                 public object DoSaveControlState ()
  93                 {
  94                         return base.SaveControlState ();
  95                 }
  96
  97                 public void DoLoadControlState (object savedState)
  98                 {
  99                          base.LoadControlState (savedState);
 100                 }
 101
 102                 public new DataSourceView GetView (string viewName)
 103                 {
 104                         return base.GetView (viewName);
 105                 }
 106         }
 107
 108         #region Hellp_class_view
 109         public class CustomObjectDataSourceView : ObjectDataSourceView
 110         {
 111                 public CustomObjectDataSourceView (ObjectDataSource owner, string name, HttpContext context)
 112                         : base (owner, name, context)
 113                 {
 114                 }
 115
 116                 public new int ExecuteUpdate (IDictionary keys, IDictionary values, IDictionary oldValues)
 117                 {
 118                         return base.ExecuteUpdate (keys, values, oldValues);
 119                 }
 120
 121                 public new int ExecuteDelete (IDictionary keys, IDictionary oldValues)
 122                 {
 123                         return base.ExecuteDelete (keys, oldValues);
 124                 }
 125
 126                 public new IEnumerable ExecuteSelect (DataSourceSelectArguments arguments)
 127                 {
 128                         return base.ExecuteSelect (arguments);
 129                 }
 130
 131                 public new int ExecuteInsert (IDictionary values)
 132                 {
 133                         return base.ExecuteInsert (values);
 134                 }
 135
 136         }
 137         #endregion
 138
 139         [TestFixture]
 140         public class ObjectDataSourceTest
 141         {
 142                 bool eventChecker;
 143                 [TestFixtureTearDown]
 144                 public void TearDown ()
 145                 {
 146                         WebTest.Unload ();
 147                 }
 148
 149                 public static void InitObjectDataSource (ObjectDataSourcePoker ds, string action)
 150                 {
 151                         Parameter p1, p2, p3;
 152                         switch (action) {
 153
 154                         case "insert":  p1 = new Parameter ("ID", TypeCode.String, "1004");
 155                                         p2 = new Parameter ("fname", TypeCode.String, "David");
 156                                         p3 = new Parameter ("LName", TypeCode.String, "Eli");
 157                                         break;
 158
 159                         case "update":  p1 = new Parameter ("ID", TypeCode.String, "1001");
 160                                         p2 = new Parameter ("FName", TypeCode.String, "David");
 161                                         p3 = new Parameter ("LName", TypeCode.String, "Eli");
 162                                         break;
 163                         case "DBNull":  p1 = new Parameter ("ID");
 164                                         p2 = new Parameter ("FName");
 165                                         p3 = new Parameter ("LName");
 166                                         break;
 167
 168                         default:        p1 = new Parameter ("ID", TypeCode.String, "1001");
 169                                         p2 = new Parameter ("FName", TypeCode.String, "Mahesh");
 170                                         p3 = new Parameter ("LName", TypeCode.String, "chand");
 171                                         break;
 172
 173                         }
 174                         ds.SelectMethod = "GetMyData";
 175                         ds.DeleteMethod = "Delete";
 176                         ds.InsertMethod = "Insert";
 177                         ds.UpdateMethod = "Update";
 178                         ds.SelectCountMethod = "SelectCount";
 179                         ds.DeleteParameters.Add (p1);
 180                         ds.DeleteParameters.Add (p2);
 181                         ds.DeleteParameters.Add (p3);
 182                         ds.InsertParameters.Add (p1);
 183                         ds.InsertParameters.Add (p2);
 184                         ds.InsertParameters.Add (p3);
 185                         ds.UpdateParameters.Add (p1);
 186                         ds.UpdateParameters.Add (p2);
 187                         ds.UpdateParameters.Add (p3);
 188                         ds.ID = "MyObject";
 189                         ds.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
 190
 191
 192                 }
 193
 194                 //Default properties
 195
 196
 197                 [Test]
 198                 public void ObjectDataSource_DefaultProperties ()
 199                 {
 200                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 201
 202                         Assert.AreEqual (ConflictOptions.OverwriteChanges, ods.ConflictDetection, "ConflictDetection");
 203                         Assert.AreEqual ("",ods.DataObjectTypeName ,"DataObjectTypeName ");
 204                         Assert.AreEqual ("", ods.DeleteMethod, "DeleteMethod");
 205                         Assert.AreEqual (typeof(ParameterCollection),ods.DeleteParameters.GetType (),"DeleteParameters");
 206                         Assert.AreEqual (false, ods.EnablePaging, "EnablePaging ");
 207                         Assert.AreEqual ("", ods.FilterExpression, "FilterExpression ");
 208                         Assert.AreEqual (typeof (ParameterCollection), ods.FilterParameters.GetType (), "FilterParameters");
 209                         Assert.AreEqual ("", ods.InsertMethod, "InsertMethod ");
 210                         Assert.AreEqual (typeof (ParameterCollection), ods.InsertParameters.GetType (), "InsertParameters ");
 211                         Assert.AreEqual ("maximumRows", ods.MaximumRowsParameterName, "MaximumRowsParameterName");
 212                         Assert.AreEqual ("{0}", ods.OldValuesParameterFormatString, "OldValuesParameterFormatString");
 213                         Assert.AreEqual ("", ods.SelectCountMethod, "SelectCountMethod");
 214                         Assert.AreEqual ("", ods.SelectMethod, "SelectMethod ");
 215                         Assert.AreEqual (typeof (ParameterCollection), ods.SelectParameters.GetType (), "SelectParameters");
 216                         Assert.AreEqual ("", ods.SortParameterName, "SortParameterName");
 217                         Assert.AreEqual ("startRowIndex", ods.StartRowIndexParameterName, "StartRowIndexParameterName");
 218                         Assert.AreEqual ("", ods.TypeName, "TypeName");
 219                         Assert.AreEqual ("", ods.UpdateMethod, "UpdateMethod ");
 220                         Assert.AreEqual (typeof (ParameterCollection), ods.UpdateParameters.GetType (), "UpdateParameters");
 221                         Assert.AreEqual (0, ods.CacheDuration, "CacheDuration");
 222                         Assert.AreEqual (DataSourceCacheExpiry.Absolute, ods.CacheExpirationPolicy, "CacheExpirationPolicy");
 223                         Assert.AreEqual ("", ods.CacheKeyDependency, "CacheKeyDependency");
 224                         Assert.AreEqual (false, ods.ConvertNullToDBNull, "ConvertNullToDBNull ");
 225                         Assert.AreEqual (false, ods.EnableCaching, "EnableCaching ");
 226                         Assert.AreEqual ("", ods.SqlCacheDependency, "SqlCacheDependency");
 227
 228                 }
 229
 230                 //Non default properties values
 231
 232                 [Test]
 233                 public void ObjectDataSource_AssignToDefaultProperties ()
 234                 {
 235                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 236                         InitObjectDataSource (ods,"");
 237                         ods.ConflictDetection = ConflictOptions.CompareAllValues;
 238                         Assert.AreEqual (ConflictOptions.CompareAllValues, ods.ConflictDetection, "ConflictDetection");
 239                         ods.DataObjectTypeName = "MyData";
 240                         Assert.AreEqual ("MyData", ods.DataObjectTypeName, "DataObjectTypeName ");
 241                         Assert.AreEqual ("Delete", ods.DeleteMethod, "DeleteMethod");
 242                         Assert.AreEqual (3, ods.DeleteParameters.Count, "DeleteParameters");
 243                         ods.EnablePaging = true;
 244                         Assert.AreEqual (true, ods.EnablePaging, "EnablePaging ");
 245                         ods.FilterExpression = "ID='{0}'";
 246                         Assert.AreEqual ("ID='{0}'", ods.FilterExpression, "FilterExpression ");
 247                         TextBox TextBox1=new TextBox ();
 248                         TextBox1.Text ="1001";
 249                         FormParameter p=new FormParameter ("ID","TextBox1");
 250                         p.DefaultValue = "1002";
 251                         ods.FilterParameters.Add (p);
 252                         Assert.AreEqual ("ID", ods.FilterParameters[0].Name, "FilterParameters1");
 253                         Assert.AreEqual ("1002", ods.FilterParameters[0].DefaultValue , "FilterParameters2");
 254                         Assert.AreEqual ("TextBox1", ((FormParameter )ods.FilterParameters[0]).FormField, "FilterParameters3");
 255                         Assert.AreEqual ("Insert", ods.InsertMethod, "InsertMethod ");
 256                         Assert.AreEqual ("ID", ods.InsertParameters[0].Name , "InsertParameters ");
 257                         ods.MaximumRowsParameterName = "SelectCount";
 258                         Assert.AreEqual ("SelectCount", ods.MaximumRowsParameterName, "MaximumRowsParameterName");
 259                         ods.OldValuesParameterFormatString = "ID";
 260                         Assert.AreEqual ("ID", ods.OldValuesParameterFormatString, "OldValuesParameterFormatString");
 261                         Assert.AreEqual ("SelectCount", ods.SelectCountMethod, "SelectCountMethod");
 262                         Assert.AreEqual ("GetMyData", ods.SelectMethod, "SelectMethod ");
 263                         Parameter dummy = new Parameter ();
 264                         dummy.Name = "Test";
 265                         ods.SelectParameters.Add (dummy);
 266                         Assert.AreEqual ("Test", ods.SelectParameters[0].Name , "SelectParameters");
 267                         ods.SortParameterName = "sortExpression";
 268                         Assert.AreEqual ("sortExpression", ods.SortParameterName, "SortParameterName");
 269                         ods.StartRowIndexParameterName = "ID";
 270                         Assert.AreEqual ("ID", ods.StartRowIndexParameterName, "StartRowIndexParameterName");
 271                         Assert.AreEqual (typeof (MyTableObject).AssemblyQualifiedName, ods.TypeName, "TypeName");
 272                         Assert.AreEqual ("Update", ods.UpdateMethod, "UpdateMethod ");
 273                         Assert.AreEqual ("FName", ods.UpdateParameters[1].Name, "UpdateParameters");
 274                         ods.CacheDuration = 1000;
 275                         Assert.AreEqual (1000, ods.CacheDuration, "CacheDuration");
 276                         ods.CacheExpirationPolicy = DataSourceCacheExpiry.Sliding;
 277                         Assert.AreEqual (DataSourceCacheExpiry.Sliding, ods.CacheExpirationPolicy, "CacheExpirationPolicy");
 278                         ods.CacheKeyDependency = "ID";
 279                         Assert.AreEqual ("ID", ods.CacheKeyDependency, "CacheKeyDependency");
 280                         ods.ConvertNullToDBNull = true;
 281                         Assert.AreEqual (true, ods.ConvertNullToDBNull, "ConvertNullToDBNull ");
 282                         ods.EnableCaching = true;
 283                         Assert.AreEqual (true, ods.EnableCaching, "EnableCaching ");
 284                         ods.SqlCacheDependency = "Northwind:Employees";
 285                         Assert.AreEqual ("Northwind:Employees", ods.SqlCacheDependency, "SqlCacheDependency");
 286
 287                 }
 288
 289                 //ViewState
 290
 291                 [Test]
 292                 public void ObjectDataSource_ViewState ()
 293                 {
 294                         ObjectDataSourcePoker  ods = new ObjectDataSourcePoker ();
 295                         //InitObjectDataSource (ods,"");
 296
 297                         ods.CacheDuration = 1;
 298                         ods.CacheExpirationPolicy = DataSourceCacheExpiry.Sliding;
 299                         ods.CacheKeyDependency = "key";
 300                         ods.ConflictDetection = ConflictOptions.CompareAllValues;
 301                         ods.ConvertNullToDBNull = true;
 302                         ods.DataObjectTypeName = "DataObjectType";
 303                         ods.DeleteMethod = "deleteMethod";
 304                         ods.EnableCaching = true;
 305                         ods.EnablePaging = true;
 306                         ods.FilterExpression = "filter expression";
 307                         ods.InsertMethod = "insertMethod";
 308                         ods.MaximumRowsParameterName = "maxRows";
 309                         ods.OldValuesParameterFormatString = "old_{0}";
 310                         ods.SelectCountMethod = "selectCountMethod";
 311                         ods.SelectMethod = "selectMethod";
 312                         ods.SortParameterName = "sortParamName";
 313                         ods.SqlCacheDependency = "cacheDependency";
 314                         ods.StartRowIndexParameterName = "startRow";
 315                         ods.TypeName = "TypeName";
 316                         ods.UpdateMethod = "updateMethod";
 317
 318                         object state = ods.SaveState ();
 319                         Assert.IsNull (state, "ViewState is null");
 320
 321                         ObjectDataSourcePoker copy = new ObjectDataSourcePoker ();
 322                         copy.LoadState (state);
 323
 324                 }
 325
 326                 //Properties functionality
 327
 328                 public void ObjectDataSource_ConflictDetection ()
 329                 {
 330                         //Not implemented
 331                 }
 332
 333                 [Test]
 334                 [Category ("NunitWeb")]
 335                 public void ObjectDataSource_ConvertNullToDBNull ()
 336                 {
 337                         string html = new WebTest (PageInvoker.CreateOnLoad (new PageDelegate (ConvertNullToDBNull))).Run ();
 338                 }
 339
 340
 341                 public static void ConvertNullToDBNull (Page p)
 342                 {
 343                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 344                         InitObjectDataSource (ods,"DBNull");
 345                         bool dbnull = false;
 346                         ods.ConvertNullToDBNull = true;
 347                         try {
 348                                 ods.Delete ();
 349                         }
 350                         catch (Exception ex) {
 351                                 Assert.AreEqual (true,
 352                                         ex.Message.Contains ("type 'System.DBNull' cannot be converted to type 'System.String'") || // dotnet
 353                                         ex.Message.Contains ("type System.DBNull cannot be converted to target type: System.String")); // mono
 354                                 dbnull = true;
 355                         }
 356                         Assert.AreEqual (true, dbnull, "ConvertNullToDBNull2");
 357                 }
 358
 359                 [Test]
 360                 [Category ("NunitWeb")]
 361                 public void ObjectDataSource_FilterExpression ()
 362                 {
 363                         string html = new WebTest (PageInvoker.CreateOnLoad (
 364                                 new PageDelegate (FilterExpression))).Run ();
 365                         string newHtml= HtmlDiff.GetControlFromPageHtml (html);
 366                         string origHtml = "<table cellspacing=\"0\" rules=\"all\" border=\"1\" style=\"border-collapse:collapse;\">\r\n\t<tr>\r\n\t\t<td>ID</td><td>FName</td><td>LName</td>\r\n\t</tr><tr>\r\n\t\t<td>1002</td><td>Melanie</td><td>Talmadge</td>\r\n\t</tr>\r\n</table>";
 367                         HtmlDiff.AssertAreEqual (origHtml, newHtml, "FilterExpression");
 368                 }
 369
 370
 371                 public static void FilterExpression (Page p)
 372                 {
 373                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
 374                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
 375                         DataGrid dg = new DataGrid ();
 376                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 377                         InitObjectDataSource (ods, "");
 378                         ods.FilterExpression = "ID='1002'";
 379                         p.Controls.Add (lcb);
 380                         p.Controls.Add (dg);
 381                         p.Controls.Add (ods);
 382                         p.Controls.Add (lce);
 383                         dg.DataSource = ods;
 384                         dg.DataBind ();
 385
 386                 }
 387
 388                 [Test]
 389                 [Category ("NunitWeb")]
 390                 public void ObjectDataSource_FilterParameter ()
 391                 {
 392                         string html = new WebTest (PageInvoker.CreateOnLoad (
 393                                 new PageDelegate (FilterParameter))).Run ();
 394                         string newHtml = HtmlDiff.GetControlFromPageHtml (html);
 395                         string origHtml = "<table cellspacing=\"0\" rules=\"all\" border=\"1\" style=\"border-collapse:collapse;\">\r\n\t<tr>\r\n\t\t<td>ID</td><td>FName</td><td>LName</td>\r\n\t</tr><tr>\r\n\t\t<td>1003</td><td>Vinay</td><td>Bansal</td>\r\n\t</tr>\r\n</table>";
 396                         HtmlDiff.AssertAreEqual (origHtml, newHtml, "FilterExpression");
 397                 }
 398
 399                 public static void FilterParameter (Page p)
 400                 {
 401                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
 402                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
 403                         DataGrid dg = new DataGrid ();
 404                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 405                         InitObjectDataSource (ods, "");
 406                         ods.FilterExpression = "{0}";
 407                         Parameter p1 = new Parameter ("ID", TypeCode.String, "ID=1003");
 408                         ods.FilterParameters.Add (p1);
 409                         p.Controls.Add (lcb);
 410                         p.Controls.Add (dg);
 411                         p.Controls.Add (ods);
 412                         p.Controls.Add (lce);
 413                         dg.DataSource = ods;
 414                         dg.DataBind ();
 415
 416                 }
 417
 418
 419                 [Test]
 420                 [Category ("NunitWeb")]
 421                 public void ObjectDataSource_EnablePaging ()
 422                 {
 423                         string html = new WebTest (PageInvoker.CreateOnLoad (
 424                                 new PageDelegate (EnablePaging))).Run ();
 425                         string newHtml = HtmlDiff.GetControlFromPageHtml (html);
 426 #if NET_4_0
 427                         string origHtml = "<div>\r\n\t<table cellspacing=\"0\" rules=\"all\" border=\"1\" style=\"border-collapse:collapse;\">\r\n\t\t<tr>\r\n\t\t\t<th scope=\"col\">Name</th><th scope=\"col\">Number</th>\r\n\t\t</tr><tr>\r\n\t\t\t<td>Number0</td><td>0</td>\r\n\t\t</tr><tr>\r\n\t\t\t<td>Number1</td><td>1</td>\r\n\t\t</tr><tr>\r\n\t\t\t<td>Number2</td><td>2</td>\r\n\t\t</tr><tr>\r\n\t\t\t<td>Number3</td><td>3</td>\r\n\t\t</tr><tr>\r\n\t\t\t<td>Number4</td><td>4</td>\r\n\t\t</tr><tr>\r\n\t\t\t<td colspan=\"2\"><table>\r\n\t\t\t\t<tr>\r\n\t\t\t\t\t<td><span>1</span></td><td><a href=\"javascript:__doPostBack(&#39;ctl01&#39;,&#39;Page$2&#39;)\">2</a></td><td><a href=\"javascript:__doPostBack(&#39;ctl01&#39;,&#39;Page$3&#39;)\">3</a></td><td><a href=\"javascript:__doPostBack(&#39;ctl01&#39;,&#39;Page$4&#39;)\">4</a></td>\r\n\t\t\t\t</tr>\r\n\t\t\t</table></td>\r\n\t\t</tr>\r\n\t</table>\r\n</div>";
 428 #else
 429                         string origHtml = "<div>\r\n\t<table cellspacing=\"0\" rules=\"all\" border=\"1\" style=\"border-collapse:collapse;\">\r\n\t\t<tr>\r\n\t\t\t<th scope=\"col\">Name</th><th scope=\"col\">Number</th>\r\n\t\t</tr><tr>\r\n\t\t\t<td>Number0</td><td>0</td>\r\n\t\t</tr><tr>\r\n\t\t\t<td>Number1</td><td>1</td>\r\n\t\t</tr><tr>\r\n\t\t\t<td>Number2</td><td>2</td>\r\n\t\t</tr><tr>\r\n\t\t\t<td>Number3</td><td>3</td>\r\n\t\t</tr><tr>\r\n\t\t\t<td>Number4</td><td>4</td>\r\n\t\t</tr><tr>\r\n\t\t\t<td colspan=\"2\"><table border=\"0\">\r\n\t\t\t\t<tr>\r\n\t\t\t\t\t<td><span>1</span></td><td><a href=\"javascript:__doPostBack('ctl01','Page$2')\">2</a></td><td><a href=\"javascript:__doPostBack('ctl01','Page$3')\">3</a></td><td><a href=\"javascript:__doPostBack('ctl01','Page$4')\">4</a></td>\r\n\t\t\t\t</tr>\r\n\t\t\t</table></td>\r\n\t\t</tr>\r\n\t</table>\r\n</div>";
 430 #endif
 431                         HtmlDiff.AssertAreEqual (origHtml, newHtml, "EnablePaging");
 432                 }
 433
 434                 public static void EnablePaging (Page p)
 435                 {
 436                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
 437                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
 438                         GridView  gv = new GridView ();
 439                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 440                         ods.ID = "ObjectDataSource1";
 441                         ods.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
 442                         ods.SelectMethod = "SelectForPaging";
 443                         ods.EnablePaging = true;
 444                         ods.SelectCountMethod = "SelectCount";
 445                         ods.MaximumRowsParameterName = "maxRows";
 446                         ods.StartRowIndexParameterName = "startIndex";
 447                         gv.AllowPaging = true;
 448                         gv.PageSize = 5;
 449                         p.Controls.Add (lcb);
 450                         p.Controls.Add (gv);
 451                         p.Controls.Add (ods);
 452                         p.Controls.Add (lce);
 453                         gv.DataSourceID = "ObjectDataSource1";
 454                         gv.DataBind ();
 455
 456                 }
 457
 458                 //public methods
 459
 460                 [Test]
 461                 [Category ("NunitWeb")]
 462                 public void ObjectDataSource_Delete ()
 463                 {
 464                         string html = new WebTest (PageInvoker.CreateOnLoad (
 465                                 new PageDelegate (DeleteMethod))).Run ();
 466                         string newHtml = HtmlDiff.GetControlFromPageHtml (html);
 467                         string origHtml = "<div>\r\n\t<table cellspacing=\"0\" rules=\"all\" border=\"1\" style=\"border-collapse:collapse;\">\r\n\t\t<tr>\r\n\t\t\t<td>ID</td><td>1002</td>\r\n\t\t</tr><tr>\r\n\t\t\t<td>FName</td><td>Melanie</td>\r\n\t\t</tr><tr>\r\n\t\t\t<td>LName</td><td>Talmadge</td>\r\n\t\t</tr>\r\n\t</table>\r\n</div>";
 468
 469                         HtmlDiff.AssertAreEqual (origHtml, newHtml, "DeleteRender");
 470                 }
 471
 472                 public static void DeleteMethod (Page p)
 473                 {
 474                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
 475                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
 476                         MyTableObject.ds = MyTableObject.CreateDataTable ();
 477                         DetailsView dv = new DetailsView ();
 478                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 479                         ods.Deleted += new ObjectDataSourceStatusEventHandler (odc_Deleted);
 480                         ods.Deleting += new ObjectDataSourceMethodEventHandler (odc_Deleting);
 481                         InitObjectDataSource (ods,"");
 482                         dv.Page = p;
 483                         ods.Page = p;
 484                         dv.DataKeyNames = new string[] { "ID" };
 485                         dv.DataSource = ods;
 486                         p.Controls.Add (lcb);
 487                         p.Controls.Add (ods);
 488                         p.Controls.Add (dv);
 489                         p.Controls.Add (lce);
 490                         dv.DataBind ();
 491                         Assert.AreEqual (3, dv.DataItemCount, "BeforeDelete1");
 492                         Assert.AreEqual (1001, dv.SelectedValue, "BeforeDelete2");
 493                         Assert.AreEqual (false, deleting, "BeforeDeletingEvent");
 494                         Assert.AreEqual (false, deleted, "BeforeDeletedEvent");
 495                         ods.Delete ();
 496                         dv.DataBind ();
 497                         Assert.AreEqual (true, deleting, "AfterDeletingEvent");
 498                         Assert.AreEqual (true, deleted, "AfterDeletedEvent");
 499                         Assert.AreEqual (2, dv.DataItemCount, "BeforeDelete1");
 500                         Assert.AreEqual (1002, dv.SelectedValue, "BeforeDelete2");
 501                 }
 502
 503                 [Test]
 504                 [Category ("NunitWeb")]
 505                 public void ObjectDataSource_Select ()
 506                 {
 507                         string html = new WebTest (PageInvoker.CreateOnLoad (
 508                                 new PageDelegate (SelectMethod))).Run ();
 509                 }
 510
 511
 512                 public static void SelectMethod (Page p)
 513                 {
 514                         MyTableObject.ds = MyTableObject.CreateDataTable ();
 515                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 516                         InitObjectDataSource (ods,"");
 517                         ods.Selected += new ObjectDataSourceStatusEventHandler (odc_Selected);
 518                         ods.Selecting += new ObjectDataSourceSelectingEventHandler (odc_Selecting);
 519                         p.Controls.Add (ods);
 520                         Assert.AreEqual (false, selecting, "BeforeSelectingEvent");
 521                         Assert.AreEqual (false, selected, "BeforeSelectedEvent");
 522                         IEnumerable table = (IEnumerable) ods.Select ();
 523                         Assert.AreEqual (3,((DataView) table).Count, "ItemsCount");
 524                         Assert.AreEqual ("Mahesh", ((DataView) table)[0].Row.ItemArray[1], "FirstItemData");
 525                         Assert.AreEqual (1002, ((DataView) table)[1].Row.ItemArray[0], "SecondItemData");
 526                         Assert.AreEqual ("Bansal", ((DataView) table)[2].Row.ItemArray[2], "ThirdItemData");
 527                         Assert.AreEqual (true, selecting, "AfterSelectingEvent");
 528                         Assert.AreEqual (true, selected, "AfterSelectedEvent");
 529                 }
 530
 531                 [Test]
 532                 [Category ("NunitWeb")]
 533                 public void ObjectDataSource_Select_Cached ()
 534                 {
 535                         string html = new WebTest (PageInvoker.CreateOnLoad (
 536                                 new PageDelegate (SelectMethodCached))).Run ();
 537                 }
 538
 539
 540                 public static void SelectMethodCached (Page p)
 541                 {
 542                         MyTableObject.ds = MyTableObject.CreateDataTable ();
 543                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 544                         ods.EnableCaching = true;
 545                         InitObjectDataSource (ods, "");
 546                         p.Controls.Add (ods);
 547                         ods.Selecting += new ObjectDataSourceSelectingEventHandler (odc_Selecting);
 548
 549                         selecting = false;
 550                         IEnumerable table = (IEnumerable) ods.Select ();
 551                         Assert.AreEqual (true, selecting, "AfterSelectingEvent");
 552
 553                         selecting = false;
 554                         IEnumerable table2 = (IEnumerable) ods.Select ();
 555                         Assert.AreEqual (false, selecting, "AfterSelectingEvent");
 556                 }
 557                 [Test]
 558                 [Category ("NunitWeb")]
 559                 public void ObjectDataSource_Insert ()
 560                 {
 561                         string html = new WebTest (PageInvoker.CreateOnLoad (
 562                                 new PageDelegate (InsertMethod))).Run ();
 563                 }
 564
 565                 public static void InsertMethod (Page p)
 566                 {
 567                         MyTableObject.ds = MyTableObject.CreateDataTable ();
 568                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 569                         InitObjectDataSource (ods,"insert");
 570                         ods.Inserted += new ObjectDataSourceStatusEventHandler (odc_Inserted);
 571                         ods.Inserting += new ObjectDataSourceMethodEventHandler (odc_Inserting);
 572                         p.Controls.Add (ods);
 573                         Assert.AreEqual (3, ((DataView) ods.Select ()).Count, "BeforeInsert");
 574                         Assert.AreEqual (false, inserted , "BeforeInsertedEvent");
 575                         Assert.AreEqual (false, inserting , "BeforeInsertingEvent");
 576                         ods.Insert ();
 577                         Assert.AreEqual (4, ((DataView) ods.Select ()).Count , "AfterInsert1");
 578                         Assert.AreEqual (1004,((DataView) ods.Select ())[3].Row.ItemArray[0], "AfterInsert2");
 579                         Assert.AreEqual ("David", ((DataView) ods.Select ())[3].Row.ItemArray[1], "AfterInsert3");
 580                         Assert.AreEqual (true, inserted, "AfterInsertedEvent");
 581                         Assert.AreEqual (true, inserting, "AfterInsertingEvent");
 582
 583                 }
 584
 585                 [Test]
 586                 [Category ("NunitWeb")]
 587                 public void ObjectDataSource_Update ()
 588                 {
 589                         string html = new WebTest (PageInvoker.CreateOnLoad (
 590                                 new PageDelegate (UpdateMethod))).Run ();
 591                 }
 592
 593                 public static void UpdateMethod (Page p)
 594                 {
 595                         MyTableObject.ds = MyTableObject.CreateDataTable ();
 596                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 597                         InitObjectDataSource (ods, "update");
 598                         ods.Updated += new ObjectDataSourceStatusEventHandler (odc_Updated);
 599                         ods.Updating += new ObjectDataSourceMethodEventHandler (odc_Updating);
 600                         p.Controls.Add (ods);
 601                         Assert.AreEqual (3, ((DataView) ods.Select ()).Count, "BeforeUpdate1");
 602                         Assert.AreEqual (1001, ((DataView) ods.Select ())[0].Row.ItemArray[0], "BeforeUpdate2");
 603                         Assert.AreEqual ("Mahesh", ((DataView) ods.Select ())[0].Row.ItemArray[1], "BeforeUpdate3");
 604                         Assert.AreEqual ("Chand", ((DataView) ods.Select ())[0].Row.ItemArray[2], "BeforeUpdate4");
 605                         Assert.AreEqual (false, updated, "BeforeUpdateEvent");
 606                         Assert.AreEqual (false, updating, "BeforeUpdatingEvent");
 607                         ods.Update ();
 608                         Assert.AreEqual (3, ((DataView) ods.Select ()).Count, "AfterUpdate1");
 609                         Assert.AreEqual (1001, ((DataView) ods.Select ())[0].Row.ItemArray[0], "AfterUpdate2");
 610                         Assert.AreEqual ("David", ((DataView) ods.Select ())[0].Row.ItemArray[1], "AfterUpdate3");
 611                         Assert.AreEqual ("Eli", ((DataView) ods.Select ())[0].Row.ItemArray[2], "AfterUpdate4");
 612                         Assert.AreEqual (true, updated, "AfterUpdateEvent");
 613                         Assert.AreEqual (true, updating, "AfterUpdatingEvent");
 614                 }
 615
 616
 617
 618                 //Events
 619
 620                 private static bool deleted = false;
 621                 private static bool deleting = false;
 622                 private static bool filtering = false;
 623                 private static bool inserted = false;
 624                 private static bool inserting = false;
 625                 private static bool objectCreated = false;
 626                 private static bool objectCreating = false;
 627                 private static bool objectDisposing = false;
 628                 private static bool selected = false;
 629                 private static bool selecting = false;
 630                 private static bool updated = false;
 631                 private static bool updating = false;
 632
 633                 // Tests for events Select,Update,Delete and Insert include in Select,Update,Delete and Insert methods tests.
 634
 635                 [Test]
 636                 [Category ("NunitWeb")]
 637                 public void ObjectDataSource_Events ()
 638                 {
 639                         string html = new WebTest (PageInvoker.CreateOnLoad (
 640                                 new PageDelegate (EventsTest))).Run ();
 641                 }
 642
 643
 644                 public static void EventsTest (Page p)
 645                 {
 646
 647                         MyTableObject.ds = MyTableObject.CreateDataTable ();
 648                         DetailsView dv = new DetailsView  ();
 649                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 650                         ods.ObjectCreated += new ObjectDataSourceObjectEventHandler (odc_ObjectCreated);
 651                         ods.ObjectCreating += new ObjectDataSourceObjectEventHandler (odc_ObjectCreating);
 652                         InitObjectDataSource (ods,"");
 653                         ods.FilterExpression = "ID='1001'";
 654                         dv.Page = p;
 655                         ods.Page = p;
 656                         dv.DataKeyNames = new string[] { "ID" };
 657                         dv.DataSource = ods;
 658                         p.Controls.Add (ods);
 659                         p.Controls.Add (dv);
 660                         dv.DataBind ();
 661                         ods.Filtering += new ObjectDataSourceFilteringEventHandler (odc_Filtering);
 662                         Assert.AreEqual (false, filtering, "BeforeFilteringEvent");
 663                         ods.Select ();
 664                         Assert.AreEqual (true, filtering, "AfterFilteringEvent");
 665                         ods.ObjectDisposing += new ObjectDataSourceDisposingEventHandler (odc_ObjectDisposing);
 666                         //ToDo: Dispose, ObjectCreated and ObjectCreating should be tested.
 667
 668                 }
 669
 670                 static void odc_Updating (object sender, ObjectDataSourceMethodEventArgs e)
 671                 {
 672                         updating = true;
 673                 }
 674
 675                 static void odc_Updated (object sender, ObjectDataSourceStatusEventArgs e)
 676                 {
 677                         updated = true;
 678                 }
 679
 680                 static void odc_Selecting (object sender, ObjectDataSourceSelectingEventArgs e)
 681                 {
 682                         selecting = true;
 683                 }
 684
 685                 static void odc_Selected (object sender, ObjectDataSourceStatusEventArgs e)
 686                 {
 687                         selected = true;
 688                 }
 689
 690                 static void odc_ObjectDisposing (object sender, ObjectDataSourceDisposingEventArgs e)
 691                 {
 692                         objectDisposing = true;
 693                 }
 694
 695                 static void odc_ObjectCreating (object sender, ObjectDataSourceEventArgs e)
 696                 {
 697                         objectCreating = true;
 698                 }
 699
 700                 static void odc_ObjectCreated (object sender, ObjectDataSourceEventArgs e)
 701                 {
 702                         objectCreated = true;
 703                 }
 704
 705                 static void odc_Inserting (object sender, ObjectDataSourceMethodEventArgs e)
 706                 {
 707                         inserting = true;
 708                 }
 709
 710                 static void odc_Inserted (object sender, ObjectDataSourceStatusEventArgs e)
 711                 {
 712                         inserted = true;
 713                 }
 714
 715                 static void odc_Filtering (object sender, ObjectDataSourceFilteringEventArgs e)
 716                 {
 717                         filtering = true;
 718                 }
 719
 720                 static void odc_Deleting (object sender, ObjectDataSourceMethodEventArgs e)
 721                 {
 722                         deleting = true;
 723                 }
 724
 725                 static void odc_Deleted (object sender, ObjectDataSourceStatusEventArgs e)
 726                 {
 727                         deleted = true;
 728                 }
 729
 730                 [Test]
 731                 public void ObjectDataSource_SelectExecute ()
 732                 {
 733                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 734                         InitObjectDataSource (ods, "");
 735                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
 736                         view.SelectMethod = "GetMyData";
 737                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
 738                         view.SelectParameters.Add (new Parameter ("Fname", TypeCode.String, "TestSelect"));
 739                         ArrayList ls =(ArrayList) view.ExecuteSelect (new DataSourceSelectArguments (""));
 740                         Assert.AreEqual ("TestSelect", ls[0], "SelectExecute");
 741                 }
 742
 743                 [Test]
 744                 public void ObjectDataSource_SelectExecuteCaseSensitive ()
 745                 {
 746                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 747                         InitObjectDataSource (ods, "");
 748                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
 749                         view.SelectMethod = "GetMyData";
 750                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
 751                         view.SelectParameters.Add (new Parameter ("fname", TypeCode.String, "TestSelect"));
 752                         ArrayList ls = (ArrayList) view.ExecuteSelect (new DataSourceSelectArguments (""));
 753                         Assert.AreEqual ("TestSelect", ls[0], "SelectExecuteCaseSensitive");
 754                 }
 755
 756                 [Test]
 757                 public void ObjectDataSource_DeleteExecute ()
 758                 {
 759                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 760                         InitObjectDataSource (ods, "");
 761                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
 762                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
 763                         view.SelectMethod = "GetMyData";
 764                         view.DeleteMethod = "Delete";
 765                         Parameter p1, p2, p3;
 766                         p1 = new Parameter ("ID", TypeCode.String, "1001");
 767                         p2 = new Parameter ("FName", TypeCode.String, "p_Mahesh");
 768                         p3 = new Parameter ("LName", TypeCode.String, "p_chand");
 769                         view.DeleteParameters.Add (p1);
 770                         view.DeleteParameters.Add (p2);
 771                         view.DeleteParameters.Add (p3);
 772                         view.OldValuesParameterFormatString = "oldvalue_{0}";
 773
 774                         Hashtable keys = new Hashtable();
 775                         keys.Add("ID","k_test_id");
 776                         view.ExecuteDelete (keys, null);
 777                         Assert.AreEqual (true, MyTableObject.DeleteWithParamsAndKeys, "DeleteExecute");
 778                         Assert.AreEqual ("1001, p_Mahesh, p_chand, k_test_id", MyTableObject.UpdatePassedValues, "DeleteExecute Values");
 779                 }
 780
 781                 [Test]
 782                 public void ObjectDataSource_DeleteExecuteParameterCaseSensitive_1 ()
 783                 {
 784                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 785                         InitObjectDataSource (ods, "");
 786                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
 787                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
 788                         view.SelectMethod = "GetMyData";
 789                         view.DeleteMethod = "Delete";
 790                         Parameter p1, p2, p3;
 791                         p1 = new Parameter ("id", TypeCode.String, "1001");
 792                         p2 = new Parameter ("fname", TypeCode.String, "Mahesh");
 793                         p3 = new Parameter ("lname", TypeCode.String, "chand");
 794                         view.DeleteParameters.Add (p1);
 795                         view.DeleteParameters.Add (p2);
 796                         view.DeleteParameters.Add (p3);
 797                         view.OldValuesParameterFormatString = "oldvalue_{0}";
 798
 799                         Hashtable value = new Hashtable ();
 800                         value.Add ("ID", "test_id");
 801                         view.ExecuteDelete (value, null);
 802                         Assert.AreEqual (true, MyTableObject.DeleteWithParamsAndKeys, "DeleteExecuteParameterCaseSensitive");
 803                 }
 804
 805                 [Test]
 806                 public void ObjectDataSource_DeleteExecuteMethodCaseSensitive ()
 807                 {
 808                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 809                         InitObjectDataSource (ods, "");
 810                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
 811                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
 812                         view.SelectMethod = "GetMyData";
 813                         view.DeleteMethod = "delete";
 814                         Parameter p1, p2, p3;
 815                         p1 = new Parameter ("ID", TypeCode.String, "1001");
 816                         p2 = new Parameter ("FName", TypeCode.String, "Mahesh");
 817                         p3 = new Parameter ("LName", TypeCode.String, "chand");
 818                         view.DeleteParameters.Add (p1);
 819                         view.DeleteParameters.Add (p2);
 820                         view.DeleteParameters.Add (p3);
 821                         view.OldValuesParameterFormatString = "oldvalue_{0}";
 822
 823                         Hashtable value = new Hashtable ();
 824                         value.Add ("ID", "test_id");
 825                         view.ExecuteDelete (value, null);
 826                         Assert.AreEqual (true, MyTableObject.DeleteWithParamsAndKeys, "DeleteExecuteMethodCaseSensitive");
 827                 }
 828
 829                 [Test]
 830                 public void ObjectDataSource_DeleteExecuteCompareAllValues ()
 831                 {
 832                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 833                         InitObjectDataSource (ods, "");
 834                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
 835                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
 836                         view.SelectMethod = "GetMyData";
 837                         view.DeleteMethod = "DeleteOldValues";
 838                         view.ConflictDetection = ConflictOptions.CompareAllValues;
 839                         Hashtable keys;
 840                         Hashtable old_value;
 841                         Hashtable new_value;
 842                         InitializeView (view, out keys, out old_value, out new_value);
 843
 844                         view.ExecuteDelete (keys, old_value);
 845                         Assert.AreEqual (true, MyTableObject.DeleteWithOldValuesCompareAllValues, "DeleteExecuteCompareAllValues");
 846                         Assert.AreEqual ("ov_1001, ov_Mahesh, ov_chand", MyTableObject.UpdatePassedValues, "DeleteExecuteCompareAllValues Values");
 847                 }
 848
 849                 [Test]
 850                 public void ObjectDataSource_DeleteExecuteDataType ()
 851                 {
 852                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 853                         InitObjectDataSource (ods, "");
 854                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
 855                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
 856                         view.DataObjectTypeName = typeof (NewData).AssemblyQualifiedName;
 857                         view.SelectMethod = "GetMyData";
 858                         view.DeleteMethod = "Delete";
 859                         view.ConflictDetection = ConflictOptions.OverwriteChanges;
 860                         Hashtable keys;
 861                         Hashtable old_value;
 862                         Hashtable new_value;
 863                         InitializeView (view, out keys, out old_value, out new_value);
 864
 865                         view.ExecuteDelete (keys, old_value);
 866                         Assert.AreEqual (true, MyTableObject.DeleteWithDataObjectTypeName, "DeleteExecuteDataType");
 867                         Assert.AreEqual ("k_1001, , ", MyTableObject.UpdatePassedValues, "DeleteExecuteDataType Values");
 868                 }
 869
 870                 [Test]
 871                 public void ObjectDataSource_DeleteExecuteDataTypeCompareAllValues ()
 872                 {
 873                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 874                         InitObjectDataSource (ods, "");
 875                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
 876                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
 877                         view.DataObjectTypeName = typeof (NewData).AssemblyQualifiedName;
 878                         view.SelectMethod = "GetMyData";
 879                         view.DeleteMethod = "Delete";
 880                         view.ConflictDetection = ConflictOptions.CompareAllValues;
 881                         Hashtable keys;
 882                         Hashtable old_value;
 883                         Hashtable new_value;
 884                         InitializeView (view, out keys, out old_value, out new_value);
 885
 886                         view.ExecuteDelete (keys, old_value);
 887                         Assert.AreEqual (true, MyTableObject.DeleteWithDataObjectTypeName, "DeleteExecuteDataTypeCompareAllValues");
 888                         Assert.AreEqual ("ov_1001, ov_Mahesh, ov_chand", MyTableObject.UpdatePassedValues, "DeleteExecuteDataTypeCompareAllValues Values");
 889                 }
 890
 891                 [Test]
 892                 public void ObjectDataSource_InsertExecute_1 ()
 893                 {
 894                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 895                         InitObjectDataSource (ods, "");
 896                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
 897                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
 898                         view.SelectMethod = "GetMyData";
 899                         view.InsertMethod = "Insert";
 900
 901                         //This hashtable ovveride
 902                         Hashtable value = new Hashtable ();
 903                         value.Add ("ID", "test_id");
 904                         view.ExecuteInsert (value);
 905                         Assert.AreEqual (true, MyTableObject.InsertWithParameters, "InsertExecute#1");
 906                 }
 907
 908                 [Test]
 909                 public void ObjectDataSource_InsertExecute_2 ()
 910                 {
 911                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 912                         InitObjectDataSource (ods, "");
 913                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
 914                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
 915                         view.SelectMethod = "GetMyData";
 916                         view.InsertMethod = "Insert";
 917
 918                         Parameter p1, p2, p3;
 919                         p1 = new Parameter ("ID", TypeCode.String, "1001");
 920                         p2 = new Parameter ("FName", TypeCode.String, "Mahesh");
 921                         p3 = new Parameter ("LName", TypeCode.String, "chand");
 922                         view.InsertParameters.Add (p1);
 923                         view.InsertParameters.Add (p2);
 924                         view.InsertParameters.Add (p3);
 925
 926                         //This hashtable ovveride
 927                         Hashtable value = new Hashtable ();
 928                         value.Add ("T", "test_id");
 929
 930                         //Merge parameters
 931                         view.ExecuteInsert (value);
 932                         Assert.AreEqual (true, MyTableObject.InsertWithMergedParameters, "InsertExecute#2");
 933                 }
 934
 935                 [Test]
 936                 public void ObjectDataSource_InsertParametersCaseSensitive ()
 937                 {
 938                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 939                         InitObjectDataSource (ods, "");
 940                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
 941                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
 942                         view.SelectMethod = "GetMyData";
 943                         view.InsertMethod = "Insert";
 944
 945                         Parameter p1, p2, p3;
 946                         p1 = new Parameter ("id", TypeCode.String, "1001");
 947                         p2 = new Parameter ("fname", TypeCode.String, "Mahesh");
 948                         p3 = new Parameter ("lname", TypeCode.String, "chand");
 949                         view.InsertParameters.Add (p1);
 950                         view.InsertParameters.Add (p2);
 951                         view.InsertParameters.Add (p3);
 952
 953                         //This hashtable ovveride
 954                         Hashtable value = new Hashtable ();
 955                         value.Add ("t", "test_id");
 956
 957                         //Merge parameters
 958                         view.ExecuteInsert (value);
 959                         Assert.AreEqual (true, MyTableObject.InsertWithMergedParameters, "InsertParametersCaseSensitive");
 960                 }
 961
 962                 [Test]
 963                 public void ObjectDataSource_UpdateExecute_1()
 964                 {
 965                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 966                         InitObjectDataSource (ods, "");
 967                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
 968                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
 969                         view.SelectMethod = "GetMyData";
 970                         view.UpdateMethod = "Update";
 971                         Parameter p1, p2, p3;
 972                         p1 = new Parameter ("ID", TypeCode.String, "1001");
 973                         p2 = new Parameter ("FName", TypeCode.String, "Mahesh");
 974                         p3 = new Parameter ("LName", TypeCode.String, "chand");
 975                         view.UpdateParameters.Add (p1);
 976                         view.UpdateParameters.Add (p2);
 977                         view.UpdateParameters.Add (p3);
 978
 979                         view.OldValuesParameterFormatString = "oldvalue_{0}";
 980                         Hashtable value = new Hashtable ();
 981                         value.Add ("P", "1000");
 982                         view.ExecuteUpdate (value, null, null);
 983                         Assert.AreEqual (true, MyTableObject.UpdateWithOldValueCollection, "UpdateExecute#1");
 984                 }
 985
 986                 [Test]
 987                 public void ObjectDataSource_UpdateExecute_2 ()
 988                 {
 989                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
 990                         InitObjectDataSource (ods, "");
 991                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
 992                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
 993                         view.SelectMethod = "GetMyData";
 994                         view.UpdateMethod = "TryUpdate";
 995                         Parameter p1, p2, p3;
 996                         p1 = new Parameter ("ID", TypeCode.String, "1001");
 997                         p2 = new Parameter ("FName", TypeCode.String, "Mahesh");
 998                         p3 = new Parameter ("LName", TypeCode.String, "chand");
 999                         view.UpdateParameters.Add (p1);
1000                         view.UpdateParameters.Add (p2);
1001                         view.UpdateParameters.Add (p3);
1002
1003                         view.OldValuesParameterFormatString = "oldvalue_{0}";
1004                         Hashtable value = new Hashtable ();
1005                         value.Add ("P", "1001");
1006
1007                         view.ExecuteUpdate (null, value, null);
1008                         Assert.AreEqual (true, MyTableObject.UpdateWithMergedCollection, "UpdateExecute#2");
1009                 }
1010
1011                 [Test]
1012                 public void ObjectDataSource_UpdateExecute_CompareAllValues ()
1013                 {
1014                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
1015                         InitObjectDataSource (ods, "");
1016                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
1017                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
1018                         view.SelectMethod = "GetMyData";
1019                         view.UpdateMethod = "TryUpdate_1";
1020                         Parameter p1, p2, p3;
1021                         p1 = new Parameter ("ID", TypeCode.String, "1001");
1022                         p2 = new Parameter ("FName", TypeCode.String, "Mahesh");
1023                         p3 = new Parameter ("LName", TypeCode.String, "chand");
1024                         view.UpdateParameters.Add (p1);
1025                         view.UpdateParameters.Add (p2);
1026                         view.UpdateParameters.Add (p3);
1027
1028                         view.OldValuesParameterFormatString = "oldvalue_{0}";
1029                         view.ConflictDetection = ConflictOptions.CompareAllValues;
1030
1031
1032                         Hashtable value = new Hashtable ();
1033                         value.Add ("ID", "1001");
1034
1035                         view.ConflictDetection = ConflictOptions.CompareAllValues;
1036                         view.ExecuteUpdate (null,null, value);
1037                         Assert.AreEqual (true, MyTableObject.UpdateWithCompareAllValues, "CompareAllValues");
1038                 }
1039
1040                 private static void InitializeView (CustomObjectDataSourceView view, out Hashtable keys, out Hashtable old_value, out Hashtable new_value)
1041                 {
1042                         Parameter p1, p2, p3, p4;
1043                         p1 = new Parameter ("oldvalue_ID", TypeCode.String, "p_1001");
1044                         p2 = new Parameter ("FName", TypeCode.String, "p_Mahesh");
1045                         p3 = new Parameter ("LName", TypeCode.String, "p_chand");
1046                         view.UpdateParameters.Add (p1);
1047                         view.UpdateParameters.Add (p2);
1048                         view.UpdateParameters.Add (p3);
1049
1050                         p4 = new Parameter ("oldvalue_ID", TypeCode.String, "p_1001");
1051                         view.DeleteParameters.Add (p4);
1052
1053                         view.OldValuesParameterFormatString = "oldvalue_{0}";
1054
1055                         keys = new Hashtable ();
1056                         keys.Add ("ID", "k_1001");
1057
1058                         old_value = new Hashtable ();
1059                         old_value.Add ("ID", "ov_1001");
1060                         old_value.Add ("FName", "ov_Mahesh");
1061                         old_value.Add ("LName", "ov_chand");
1062
1063                         new_value = new Hashtable ();
1064                         new_value.Add ("ID", "n_1001");
1065                         new_value.Add ("FName", "n_Mahesh");
1066                         new_value.Add ("LName", "n_chand");
1067                 }
1068
1069                 [Test]
1070                 public void ObjectDataSource_UpdateExecute_CompareAllValues2 ()
1071                 {
1072                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
1073                         InitObjectDataSource (ods, "");
1074                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
1075                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
1076                         view.SelectMethod = "GetMyData";
1077                         view.UpdateMethod = "UpdateCompareAllValues";
1078                         view.ConflictDetection = ConflictOptions.CompareAllValues;
1079                         Hashtable keys;
1080                         Hashtable old_value;
1081                         Hashtable new_value;
1082                         InitializeView (view, out keys, out old_value, out new_value);
1083
1084                         view.ExecuteUpdate (keys, new_value, old_value);
1085                         Assert.AreEqual (true, MyTableObject.UpdateCompareAllValuesCalled, "CompareAllValues2");
1086                         Assert.AreEqual ("n_1001, n_Mahesh, n_chand, k_1001, ov_Mahesh, ov_chand", MyTableObject.UpdatePassedValues, "CompareAllValues2 Values");
1087                 }
1088
1089                 [Test]
1090                 public void ObjectDataSource_UpdateExecute_OverwriteChanges ()
1091                 {
1092                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
1093                         InitObjectDataSource (ods, "");
1094                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
1095                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
1096                         view.SelectMethod = "GetMyData";
1097                         view.UpdateMethod = "UpdateOverwriteChanges";
1098                         view.ConflictDetection = ConflictOptions.OverwriteChanges;
1099                         Hashtable keys;
1100                         Hashtable old_value;
1101                         Hashtable new_value;
1102                         InitializeView (view, out keys, out old_value, out new_value);
1103
1104                         view.ExecuteUpdate (keys, new_value, old_value);
1105                         Assert.AreEqual (true, MyTableObject.UpdateOverwriteChangesCalled, "OverwriteChanges");
1106                         Assert.AreEqual ("n_1001, n_Mahesh, n_chand, k_1001", MyTableObject.UpdatePassedValues, "OverwriteChanges Values");
1107                 }
1108
1109                 [Test]
1110                 public void ObjectDataSource_UpdateExecute_DataObjectTypeName ()
1111                 {
1112                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
1113                         InitObjectDataSource (ods, "");
1114                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
1115                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
1116                         view.DataObjectTypeName = typeof (NewData).AssemblyQualifiedName;
1117
1118                         view.SelectMethod = "GetMyData";
1119                         view.UpdateMethod = "Update";
1120                         view.OldValuesParameterFormatString = "oldvalue_{0}";
1121                         view.ExecuteUpdate (null, null, null);
1122                         Assert.AreEqual (true, MyTableObject.UpdateWithDataObjectTypeName, "UpdateExecute_DataObjectTypeName");
1123                         Assert.AreEqual (", , ", MyTableObject.UpdatePassedValues, "UpdateExecute_DataObjectTypeName Values");
1124                 }
1125                 [Test]
1126                 public void ObjectDataSource_UpdateExecute_DataObjectTypeName2 ()
1127                 {
1128                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
1129                         InitObjectDataSource (ods, "");
1130                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
1131                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
1132                         view.DataObjectTypeName = typeof (NewData).AssemblyQualifiedName;
1133
1134                         view.SelectMethod = "GetMyData";
1135                         view.UpdateMethod = "Update";
1136                         view.OldValuesParameterFormatString = "oldvalue_{0}";
1137                         view.ConflictDetection = ConflictOptions.OverwriteChanges;
1138                         Hashtable keys;
1139                         Hashtable old_value;
1140                         Hashtable new_value;
1141                         InitializeView (view, out keys, out old_value, out new_value);
1142
1143                         view.ExecuteUpdate (keys, new_value, old_value);
1144                         Assert.AreEqual (true, MyTableObject.UpdateWithDataObjectTypeName, "UpdateExecute_DataObjectTypeName2");
1145                         Assert.AreEqual ("n_1001, n_Mahesh, n_chand", MyTableObject.UpdatePassedValues, "UpdateExecute_DataObjectTypeName Values");
1146                 }
1147
1148
1149                 [Test]
1150                 public void ObjectDataSource_UpdateExecute_DataObjectTypeNameCompareAllValues ()
1151                 {
1152                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
1153                         InitObjectDataSource (ods, "");
1154                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
1155                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
1156                         view.DataObjectTypeName = typeof (NewData).AssemblyQualifiedName;
1157
1158                         view.SelectMethod = "GetMyData";
1159                         view.UpdateMethod = "Update";
1160                         view.OldValuesParameterFormatString = "oldvalue_{0}";
1161                         view.ConflictDetection = ConflictOptions.CompareAllValues;
1162                         Hashtable keys;
1163                         Hashtable old_value;
1164                         Hashtable new_value;
1165                         InitializeView (view, out keys, out old_value, out new_value);
1166
1167                         view.ExecuteUpdate (keys, new_value, old_value);
1168                         Assert.AreEqual (true, MyTableObject.UpdateWithDataObjectTypeNameAllValues, "UpdateExecute_DataObjectTypeNameCompareAllValues");
1169                         Assert.AreEqual ("n_1001, n_Mahesh, n_chand, k_1001, ov_Mahesh, ov_chand", MyTableObject.UpdatePassedValues, "UpdateExecute_DataObjectTypeName Values");
1170                 }
1171
1172                 [Test]
1173                 public void ObjectDataSource_DataSourceChanged ()
1174                 {
1175                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
1176                         InitObjectDataSource (ods, "");
1177                         ((IDataSource) ods).DataSourceChanged += new EventHandler (ObjectDataSourceTest_DataSourceChanged);
1178
1179                         // Check if event raised
1180                         ods.DoRaiseDataSourceChangedEvent ();
1181                         Assert.IsTrue (eventChecker, "DataSourceChanged#1");
1182
1183                         eventChecker = false;
1184                         ods.ConflictDetection = ConflictOptions.CompareAllValues;
1185                         Assert.IsFalse (eventChecker, "DataSourceChanged#2");
1186
1187                         eventChecker = false;
1188                         ods.DataObjectTypeName = "MyData";
1189                         Assert.IsFalse (eventChecker, "DataSourceChanged#3");
1190
1191                         eventChecker = false;
1192                         ods.EnablePaging = true;
1193                         Assert.IsFalse (eventChecker, "DataSourceChanged#4");
1194
1195                         eventChecker = false;
1196                         ods.FilterExpression = "ID='{0}'";
1197                         Assert.IsFalse (eventChecker, "DataSourceChanged#5");
1198
1199
1200                         eventChecker = false;
1201                         TextBox TextBox1 = new TextBox ();
1202                         TextBox1.Text = "1001";
1203                         FormParameter p = new FormParameter ("ID", "TextBox1");
1204                         p.DefaultValue = "1002";
1205                         ods.FilterParameters.Add (p);
1206                         Assert.IsFalse (eventChecker, "DataSourceChanged#6");
1207
1208                         eventChecker = false;
1209                         ods.MaximumRowsParameterName = "SelectCount";
1210                         Assert.IsFalse (eventChecker, "DataSourceChanged#7");
1211
1212                         eventChecker = false;
1213                         ods.OldValuesParameterFormatString = "ID";
1214                         Assert.IsFalse (eventChecker, "DataSourceChanged#8");
1215
1216                         eventChecker = false;
1217                         Parameter dummy = new Parameter ();
1218                         dummy.Name = "Test";
1219                         ods.SelectParameters.Add (dummy);
1220                         Assert.IsFalse (eventChecker, "DataSourceChanged#9");
1221
1222                         eventChecker = false;
1223                         ods.SortParameterName = "sortExpression";
1224                         Assert.IsFalse (eventChecker, "DataSourceChanged#10");
1225
1226                         eventChecker = false;
1227                         ods.StartRowIndexParameterName = "ID";
1228                         Assert.IsFalse (eventChecker, "DataSourceChanged#11");
1229
1230                         eventChecker = false;
1231                         ods.CacheDuration = 1000;
1232                         Assert.IsFalse (eventChecker, "DataSourceChanged#12");
1233
1234                         eventChecker = false;
1235                         ods.CacheExpirationPolicy = DataSourceCacheExpiry.Sliding;
1236                         Assert.IsFalse (eventChecker, "DataSourceChanged#13");
1237
1238                         eventChecker = false;
1239                         ods.CacheKeyDependency = "ID";
1240                         Assert.IsFalse (eventChecker, "DataSourceChanged#14");
1241
1242                         eventChecker = false;
1243                         ods.ConvertNullToDBNull = true;
1244                         Assert.IsFalse (eventChecker, "DataSourceChanged#15");
1245
1246                         eventChecker = false;
1247                         ods.EnableCaching = true;
1248                         Assert.IsFalse (eventChecker, "DataSourceChanged#16");
1249
1250                         eventChecker = false;
1251                         ods.SqlCacheDependency = "Northwind:Employees";
1252                         Assert.IsFalse (eventChecker, "DataSourceChanged#17");
1253                 }
1254
1255                 void ObjectDataSourceTest_DataSourceChanged (object sender, EventArgs e)
1256                 {
1257                         eventChecker = true;
1258                 }
1259
1260                 //Excpetions
1261                 [Test]  // Note: on ConflictOptions.CompareAllValues old values cannot be null;
1262                 [ExpectedException (typeof (InvalidOperationException))]
1263                 public void ObjectDataSource_UpdateExecute_CompareAllValues_Exception ()
1264                 {
1265                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
1266                         InitObjectDataSource (ods, "");
1267                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
1268                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
1269                         view.SelectMethod = "GetMyData";
1270                         view.UpdateMethod = "TryUpdate_1";
1271                         Parameter p1, p2, p3;
1272                         p1 = new Parameter ("ID", TypeCode.String, "1001");
1273                         p2 = new Parameter ("FName", TypeCode.String, "Mahesh");
1274                         p3 = new Parameter ("LName", TypeCode.String, "chand");
1275                         view.UpdateParameters.Add (p1);
1276                         view.UpdateParameters.Add (p2);
1277                         view.UpdateParameters.Add (p3);
1278
1279                         view.OldValuesParameterFormatString = "oldvalue_{0}";
1280                         view.ConflictDetection = ConflictOptions.CompareAllValues;
1281                         view.ExecuteUpdate (null, null, null);
1282                 }
1283
1284                 [Test]
1285                 [ExpectedException (typeof (InvalidOperationException))]
1286                 public void ObjectDataSource_UpdateExecute_3 ()
1287                 {
1288                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
1289                         InitObjectDataSource (ods, "");
1290                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
1291                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
1292                         view.SelectMethod = "GetMyData";
1293                         view.UpdateMethod = "Update";
1294                         Parameter p1, p2, p3;
1295                         p1 = new Parameter ("ID", TypeCode.String, "1001");
1296                         p2 = new Parameter ("FName", TypeCode.String, "Mahesh");
1297                         p3 = new Parameter ("LName", TypeCode.String, "chand");
1298                         view.UpdateParameters.Add (p1);
1299                         view.UpdateParameters.Add (p2);
1300                         view.UpdateParameters.Add (p3);
1301
1302                         view.OldValuesParameterFormatString = "oldvalue_{0}";
1303                         Hashtable value = new Hashtable ();
1304                         value.Add ("ID", "1000");
1305                         view.ExecuteUpdate (value, null, null);
1306                 }
1307
1308                 [Test]
1309                 [ExpectedException (typeof (InvalidOperationException))]
1310                 public void ObjectDataSource_InsertParameterException ()
1311                 {
1312                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
1313                         InitObjectDataSource (ods, "");
1314                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
1315                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
1316                         view.SelectMethod = "GetMyData";
1317                         view.InsertMethod = "Insert";
1318
1319                         Parameter p1, p2, p3;
1320                         p1 = new Parameter ("id", TypeCode.String, "1001");
1321                         p2 = new Parameter ("fname", TypeCode.String, "Mahesh");
1322                         p3 = new Parameter ("lname", TypeCode.String, "chand");
1323                         view.InsertParameters.Add (p1);
1324                         view.InsertParameters.Add (p2);
1325                         view.InsertParameters.Add (p3);
1326
1327                         //This hashtable ovveride
1328                         Hashtable value = new Hashtable ();
1329                         value.Add ("z", "test_id");
1330
1331                         //Merge parameters
1332                         view.ExecuteInsert (value);
1333                         Assert.AreEqual (true, MyTableObject.InsertWithMergedParameters, "InsertExecute");
1334                 }
1335
1336                 [Test]
1337                 [ExpectedException (typeof (InvalidOperationException))]
1338                 public void ObjectDataSource_DeleteExecuteMethodParameterException()
1339                 {
1340                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
1341                         InitObjectDataSource (ods, "");
1342                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
1343                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
1344                         view.SelectMethod = "GetMyData";
1345                         view.DeleteMethod = "delete";
1346                         Parameter p1, p2, p3;
1347                         p1 = new Parameter ("ID", TypeCode.String, "1001");
1348                         view.DeleteParameters.Add (p1);
1349                         view.OldValuesParameterFormatString = "oldvalue_{0}";
1350                         Hashtable value = new Hashtable ();
1351                         value.Add ("ID", "test_id");
1352                         view.ExecuteDelete (value, null);
1353                 }
1354
1355                 [Test]
1356                 [ExpectedException (typeof (InvalidOperationException))]
1357                 public void ObjectDataSource_DeleteExecuteOldValueException ()
1358                 {
1359                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
1360                         InitObjectDataSource (ods, "");
1361                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
1362                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
1363                         view.SelectMethod = "GetMyData";
1364                         view.DeleteMethod = "Delete";
1365                         Parameter p1, p2, p3;
1366                         p1 = new Parameter ("ID", TypeCode.String, "1001");
1367                         p2 = new Parameter ("FName", TypeCode.String, "Mahesh");
1368                         p3 = new Parameter ("LName", TypeCode.String, "chand");
1369                         view.DeleteParameters.Add (p1);
1370                         view.DeleteParameters.Add (p2);
1371                         view.DeleteParameters.Add (p3);
1372                         view.OldValuesParameterFormatString = "oldvalue_{0}";
1373
1374                         Hashtable value = new Hashtable ();
1375                         value.Add ("ID", "test_id");
1376                         value.Add ("FName", "test_FName");
1377                         view.ExecuteDelete (value, null);
1378                         Assert.AreEqual (true, MyTableObject.DeleteWithParamsAndKeys, "DeleteExecute");
1379                 }
1380
1381                 [Test]
1382                 [ExpectedException (typeof (InvalidOperationException))]
1383                 public void ObjectDataSource_SelectExecuteException_1 ()
1384                 {
1385                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
1386                         InitObjectDataSource (ods, "");
1387                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
1388                         view.SelectMethod = "GetMyData";
1389                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
1390                         view.SelectParameters.Add (new Parameter ("Name", TypeCode.String, "TestSelect"));
1391                         IEnumerable res = view.ExecuteSelect (new DataSourceSelectArguments (""));
1392                 }
1393
1394                 [ExpectedException (typeof (InvalidOperationException))]
1395                 public void ObjectDataSource_SelectExecuteException_2 ()
1396                 {
1397                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
1398                         InitObjectDataSource (ods, "");
1399                         CustomObjectDataSourceView view = new CustomObjectDataSourceView (ods, "CustomView", null);
1400                         view.SelectMethod = "Fake";
1401                         view.TypeName = typeof (MyTableObject).AssemblyQualifiedName;
1402                         view.SelectParameters.Add (new Parameter ("Fname", TypeCode.String, "TestSelect"));
1403                         IEnumerable res = view.ExecuteSelect (new DataSourceSelectArguments (""));
1404                 }
1405
1406                 [Test]
1407                 [ExpectedException (typeof (NotSupportedException))]
1408                 [Category ("NunitWeb")]
1409                 public void ObjectDataSource_EnableCachingException ()
1410                 {
1411                         string html = new WebTest (PageInvoker.CreateOnLoad (
1412                                 new PageDelegate (EnableCachingException))).Run ();
1413                 }
1414
1415
1416                 public static void EnableCachingException (Page p)
1417                 {
1418                         MyTableObject.ds = MyTableObject.CreateDataTable ();
1419                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
1420                         InitObjectDataSource (ods, "");
1421                         ods.SelectMethod = "SelectException";
1422                         ods.EnableCaching = true;
1423                         p.Controls.Add (ods);
1424                         IEnumerable table = (IEnumerable) ods.Select ();
1425
1426                 }
1427
1428                 [Test]
1429                 [ExpectedException (typeof (NotSupportedException))]
1430                 [Category ("NunitWeb")]
1431                 public void ObjectDataSource_FilterExpressionException ()
1432                 {
1433                         string html = new WebTest (PageInvoker.CreateOnLoad (
1434                                 new PageDelegate (FilterExpressionException))).Run ();
1435                 }
1436
1437
1438                 public static void FilterExpressionException (Page p)
1439                 {
1440                         MyTableObject.ds = MyTableObject.CreateDataTable ();
1441                         ObjectDataSourcePoker ods = new ObjectDataSourcePoker ();
1442                         InitObjectDataSource (ods, "");
1443                         ods.SelectMethod = "SelectException";
1444                         ods.FilterExpression  = "ID='1001'";
1445                         p.Controls.Add (ods);
1446                         IEnumerable table = (IEnumerable) ods.Select ();
1447                 }
1448         }
1449
1450         # region Object_Data_Source_DAL
1451         public class MyTableObject
1452         {
1453                 public static DataTable ds = CreateDataTable ();
1454                 public MyTableObject ()
1455                 {
1456                         ResetEventCheckers ();
1457                 }
1458
1459                 public static DataTable GetMyData ()
1460                 {
1461                         return ds;
1462                 }
1463
1464                 public static ArrayList GetMyData (string Fname)
1465                 {
1466                         ArrayList ar = new ArrayList ();
1467                         ar.Add (Fname);
1468                         return ar;
1469                 }
1470
1471                 public static DbDataReader SelectException ()
1472                 {
1473                         return new DataTableReader (new DataTable ());
1474                 }
1475
1476                 public static int SelectCount ()
1477                 {
1478                         return 20;
1479                 }
1480
1481
1482                 public static DataTable Delete (string ID, string FName, string LName)
1483                 {
1484                         DataRow dr = ds.Rows.Find (ID);
1485                         ds.Rows.Remove (dr);
1486                         return ds;
1487
1488                 }
1489
1490                 public static DataTable Delete (string ID, string FName, string LName, string oldvalue_ID)
1491                 {
1492                         DeleteWithParamsAndKeys = true;
1493                         UpdatePassedValues = String.Join (", ", new string [] { ID, FName, LName, oldvalue_ID });
1494                         DataRow dr = ds.Rows.Find (ID);
1495                         try {
1496                                 ds.Rows.Remove (dr); }
1497                         catch{}
1498                         return ds;
1499                 }
1500
1501                 public static DataTable DeleteOldValues (string oldvalue_ID, string oldvalue_FName, string oldvalue_LName)
1502                 {
1503                         DeleteWithOldValuesCompareAllValues = true;
1504                         UpdatePassedValues = String.Join (", ", new string [] { oldvalue_ID, oldvalue_FName, oldvalue_LName });
1505                         return ds;
1506                 }
1507
1508                 public static DataTable Delete (NewData anyName)
1509                 {
1510                         UpdatePassedValues = String.Join (", ", new string [] { anyName.ID, anyName.FName, anyName.LName });
1511                         DeleteWithDataObjectTypeName = true;
1512                         return ds;
1513                 }
1514
1515                 public static bool DeleteWithParamsAndKeys;
1516                 public static bool DeleteWithOldValuesCompareAllValues;
1517                 public static bool DeleteWithDataObjectTypeName;
1518                 public static bool UpdateWithOldValueCollection;
1519                 public static bool UpdateWithMergedCollection;
1520                 public static bool InsertWithParameters;
1521                 public static bool InsertWithMergedParameters;
1522                 public static bool UpdateWithCompareAllValues;
1523                 public static bool UpdateWithDataObjectTypeName;
1524                 public static bool UpdateWithDataObjectTypeNameAllValues;
1525                 public static bool UpdateCompareAllValuesCalled;
1526                 public static bool UpdateOverwriteChangesCalled;
1527                 public static string UpdatePassedValues;
1528
1529                 private void ResetEventCheckers()
1530                 {
1531                         DeleteWithParamsAndKeys = false;
1532                         DeleteWithOldValuesCompareAllValues = false;
1533                         DeleteWithDataObjectTypeName = false;
1534                         InsertWithParameters = false;
1535                         InsertWithMergedParameters = false;
1536                         UpdateWithOldValueCollection = false;
1537                         UpdateWithMergedCollection = false;
1538                         UpdateWithCompareAllValues = false;
1539                         UpdateWithDataObjectTypeName = false;
1540                         UpdateWithDataObjectTypeNameAllValues = false;
1541                         UpdateCompareAllValuesCalled = false;
1542                         UpdateOverwriteChangesCalled = false;
1543                         UpdatePassedValues = "";
1544                 }
1545
1546                 public static DataTable Update (string ID, string FName, string LName)
1547                 {
1548                         DataRow dr = ds.Rows.Find (ID);
1549                         if (dr == null) {
1550                                 Label lbl = new Label ();
1551                                 lbl.Text = "ID doesn't exist. update only FName and LName";
1552                                 return ds;
1553                         }
1554                         dr["FName"] = FName;
1555                         dr["LName"] = LName;
1556                         return ds;
1557
1558                 }
1559
1560                 public static DataTable TryUpdate_1 (string ID, string FName, string LName, string oldvalue_ID)
1561                 {
1562                         UpdateWithCompareAllValues = true;
1563                         return ds;
1564                 }
1565
1566
1567                 public static DataTable TryUpdate (string ID, string FName, string LName, string P)
1568                 {
1569                         UpdateWithMergedCollection = true;
1570                         return ds;
1571                 }
1572
1573                 public static DataTable Update (string ID, string FName, string LName, string oldvalue_P )
1574                 {
1575                         UpdateWithOldValueCollection = true;
1576                         return ds;
1577                 }
1578
1579                 public static DataTable Update (NewData data)
1580                 {
1581                         UpdatePassedValues = String.Join (", ", new string [] { data.ID, data.FName, data.LName});
1582                         UpdateWithDataObjectTypeName = true;
1583                         return ds;
1584                 }
1585
1586                 public static DataTable Update (NewData data, NewData oldvalue_data)
1587                 {
1588                         UpdatePassedValues = String.Join (", ", new string [] { data.ID, data.FName, data.LName, oldvalue_data.ID, oldvalue_data.FName, oldvalue_data.LName });
1589                         UpdateWithDataObjectTypeNameAllValues = true;
1590                         return ds;
1591                 }
1592
1593                 public static DataTable UpdateCompareAllValues (string ID, string FName, string LName,
1594                                                                                                            string oldvalue_ID, string oldvalue_FName, string oldvalue_LName)
1595                 {
1596                         UpdatePassedValues = String.Join (", ", new string [] {ID, FName, LName, oldvalue_ID, oldvalue_FName, oldvalue_LName });
1597                         UpdateCompareAllValuesCalled = true;
1598                         return ds;
1599                 }
1600
1601                 public static DataTable UpdateOverwriteChanges (string ID, string FName, string LName, string oldvalue_ID)
1602                 {
1603                         UpdatePassedValues = String.Join (", ", new string [] { ID, FName, LName, oldvalue_ID });
1604                         UpdateOverwriteChangesCalled = true;
1605                         return ds;
1606                 }
1607
1608
1609                 public static DataTable Insert (string ID)
1610                 {
1611                         InsertWithParameters = true;
1612                         return ds;
1613                 }
1614
1615                 public static DataTable Insert (string ID, string FName, string LName,string T)
1616                 {
1617                         InsertWithMergedParameters = true;
1618                         return ds;
1619                 }
1620
1621                 public static DataTable Insert (string ID, string FName, string LName)
1622                 {
1623                         DataRow dr = ds.NewRow ();
1624                         dr["ID"] = ID;
1625                         dr["FName"] = FName;
1626                         dr["LName"] = LName;
1627                         ds.Rows.Add (dr);
1628                         return ds;
1629                 }
1630
1631
1632                 public static DataTable CreateDataTable ()
1633                 {
1634
1635                         DataTable aTable = new DataTable ("A");
1636                         DataColumn dtCol;
1637                         DataRow dtRow;
1638
1639                         // Create ID column and add to the DataTable.
1640
1641                         dtCol = new DataColumn ();
1642                         dtCol.DataType = Type.GetType ("System.Int32");
1643                         dtCol.ColumnName = "ID";
1644                         dtCol.AutoIncrement = true;
1645                         dtCol.Caption = "ID";
1646                         dtCol.ReadOnly = true;
1647                         dtCol.Unique = true;
1648
1649                         // Add the column to the DataColumnCollection.
1650
1651                         aTable.Columns.Add (dtCol);
1652
1653                         // Create Name column and add to the table
1654
1655                         dtCol = new DataColumn ();
1656                         dtCol.DataType = Type.GetType ("System.String");
1657                         dtCol.ColumnName = "FName";
1658                         dtCol.AutoIncrement = false;
1659                         dtCol.Caption = "First Name";
1660                         dtCol.ReadOnly = false;
1661                         dtCol.Unique = false;
1662                         aTable.Columns.Add (dtCol);
1663
1664
1665                         // Create Last Name column and add to the table.
1666
1667                         dtCol = new DataColumn ();
1668                         dtCol.DataType = Type.GetType ("System.String");
1669                         dtCol.ColumnName = "LName";
1670                         dtCol.AutoIncrement = false;
1671                         dtCol.Caption = "Last Name";
1672                         dtCol.ReadOnly = false;
1673                         dtCol.Unique = false;
1674                         aTable.Columns.Add (dtCol);
1675
1676
1677                         // Create three rows to the table
1678                         dtRow = aTable.NewRow ();
1679                         dtRow["ID"] = 1001;
1680                         dtRow["FName"] = "Mahesh";
1681                         dtRow["LName"] = "Chand";
1682                         aTable.Rows.Add (dtRow);
1683
1684
1685                         dtRow = aTable.NewRow ();
1686                         dtRow["ID"] = 1002;
1687                         dtRow["FName"] = "Melanie";
1688                         dtRow["LName"] = "Talmadge";
1689                         aTable.Rows.Add (dtRow);
1690
1691                         dtRow = aTable.NewRow ();
1692                         dtRow["ID"] = 1003;
1693                         dtRow["FName"] = "Vinay";
1694                         dtRow["LName"] = "Bansal";
1695                         aTable.Rows.Add (dtRow);
1696
1697                         aTable.PrimaryKey = new DataColumn[] { aTable.Columns["ID"] };
1698                         return aTable;
1699
1700                 }
1701
1702                 public static DataTable SelectForPaging (int startIndex, int maxRows)
1703                 {
1704                         DataTable table = new DataTable ();
1705                         table.Columns.Add ("Name", typeof (string));
1706                         table.Columns.Add ("Number", typeof (int));
1707                         int current;
1708                         for (int i = 0; i < maxRows; i++) {
1709                                 current = i + startIndex;
1710                                 table.Rows.Add (new object[] { "Number" + current.ToString (), current });
1711                         }
1712                         return table;
1713                 }
1714
1715
1716
1717         }
1718         #endregion
1719
1720         #region DataObjectTypeName
1721         public class NewData
1722         {
1723                 private string IDValue;
1724                 private string FNameValue;
1725                 private string LNameValue;
1726
1727                 public string LName
1728                 {
1729                         get { return LNameValue; }
1730                         set { LNameValue = value; }
1731                 }
1732
1733                 public string FName
1734                 {
1735                         get { return FNameValue; }
1736                         set { FNameValue = value; }
1737                 }
1738
1739                 public string ID
1740                 {
1741                         get { return IDValue; }
1742                         set { IDValue = value; }
1743                 }
1744
1745         }
1746         #endregion
1747
1748 }
1749 #endif