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

   1 //
   2 // Tests for System.Web.UI.WebControls.SqlDataSourceView
   3 //
   4 // Author:
   5 //      Chris Toshok (toshok@novell.com)
   6 //
   7
   8 //
   9 // Copyright (C) 2006 Novell, Inc (http://www.novell.com)
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30
  31 #if NET_2_0
  32
  33 using NUnit.Framework;
  34 using System;
  35 using System.Configuration;
  36 using System.Data.Common;
  37 using System.IO;
  38 using System.Globalization;
  39 using System.Web;
  40 using System.Web.UI;
  41 using System.Web.UI.WebControls;
  42 using System.Collections;
  43 using System.Data.SqlClient;
  44 using System.Text;
  45
  46 namespace MonoTests.System.Web.UI.WebControls
  47 {
  48         class SqlViewPoker : SqlDataSourceView {
  49                 public SqlViewPoker (SqlDataSource ds, string name, HttpContext context)
  50                         : base (ds, name, context)
  51                 {
  52                         TrackViewState ();
  53                 }
  54
  55                 public object SaveToViewState ()
  56                 {
  57                         return SaveViewState ();
  58                 }
  59
  60                 public void LoadFromViewState (object savedState)
  61                 {
  62                         LoadViewState (savedState);
  63                 }\r
  64 \r
  65                 public void DoOnDataSourceViewChanged ()\r
  66                 {\r
  67                         base.OnDataSourceViewChanged (new EventArgs());\r
  68                 }
  69         }
  70
  71         [TestFixture]
  72         public class SqlDataSourceViewTest
  73         {
  74                 [SetUp]
  75                 public void Setup ()
  76                 {
  77                         eventsCalled = null;
  78                 }
  79
  80                 [Test]
  81                 public void Defaults ()
  82                 {
  83                         SqlDataSource ds = new SqlDataSource ();
  84                         SqlViewPoker sql = new SqlViewPoker (ds, "DefaultView", null);
  85
  86                         Assert.IsTrue (sql.CancelSelectOnNullParameter, "A1");
  87                         Assert.IsFalse (sql.CanDelete,"A2");
  88                         Assert.IsFalse (sql.CanInsert,"A3");
  89                         Assert.IsFalse (sql.CanPage,"A4");
  90                         Assert.IsFalse (sql.CanRetrieveTotalRowCount,"A5");
  91                         Assert.IsTrue (sql.CanSort,"A6");
  92                         Assert.IsFalse (sql.CanUpdate,"A7");
  93                         Assert.AreEqual (ConflictOptions.OverwriteChanges, sql.ConflictDetection, "A8");
  94                         Assert.AreEqual ("", sql.DeleteCommand, "A9");
  95                         Assert.AreEqual (SqlDataSourceCommandType.Text, sql.DeleteCommandType, "A10");
  96                         Assert.IsNotNull (sql.DeleteParameters, "A11");
  97                         Assert.AreEqual (0, sql.DeleteParameters.Count, "A12");
  98                         Assert.AreEqual ("", sql.FilterExpression, "A13");
  99                         Assert.IsNotNull (sql.FilterParameters, "A14");
 100                         Assert.AreEqual (0, sql.FilterParameters.Count, "A15");
 101                         Assert.AreEqual ("", sql.InsertCommand, "A16");
 102                         Assert.AreEqual (SqlDataSourceCommandType.Text, sql.InsertCommandType, "A17");
 103                         Assert.IsNotNull (sql.InsertParameters, "A18");
 104                         Assert.AreEqual (0, sql.InsertParameters.Count, "A19");
 105                         Assert.AreEqual ("{0}", sql.OldValuesParameterFormatString, "A20");
 106                         Assert.AreEqual ("", sql.SelectCommand, "A21");
 107                         Assert.AreEqual (SqlDataSourceCommandType.Text, sql.SelectCommandType, "A22");
 108                         Assert.IsNotNull (sql.SelectParameters, "A23");
 109                         Assert.AreEqual (0, sql.SelectParameters.Count, "A24");
 110                         Assert.AreEqual ("", sql.SortParameterName, "A25");
 111                         Assert.AreEqual ("", sql.UpdateCommand, "A26");
 112                         Assert.AreEqual (SqlDataSourceCommandType.Text, sql.UpdateCommandType, "A27");
 113                         Assert.IsNotNull (sql.UpdateParameters, "A28");
 114                         Assert.AreEqual (0, sql.UpdateParameters.Count, "A29");
 115                 }
 116
 117                 [Test]
 118                 public void ViewStateSupport ()
 119                 {
 120                         SqlDataSource ds = new SqlDataSource ();
 121                         SqlViewPoker view = new SqlViewPoker (ds, "DefaultView", null);
 122
 123                         ds.ID = "SqlDataSource1";
 124                         ds.SelectCommand = "Select";
 125
 126                         Parameter p1 = new Parameter ("test", TypeCode.String);
 127
 128                         Assert.IsTrue (((IStateManager) view).IsTrackingViewState, "IsTrackingViewState");
 129                         Assert.IsTrue (((IStateManager) view.FilterParameters).IsTrackingViewState, "FilterParameters.IsTrackingViewState");
 130                         Assert.IsTrue (((IStateManager) view.SelectParameters).IsTrackingViewState, "SelecteParameters.IsTrackingViewState");
 131                         Assert.IsFalse (((IStateManager) view.DeleteParameters).IsTrackingViewState, "DeleteParameters.IsTrackingViewState");
 132                         Assert.IsFalse (((IStateManager) view.InsertParameters).IsTrackingViewState, "InsertParameters.IsTrackingViewState");
 133                         Assert.IsFalse (((IStateManager) view.UpdateParameters).IsTrackingViewState, "UpdateParameters.IsTrackingViewState");
 134
 135                         object state = ((IStateManager) view).SaveViewState ();
 136                         Assert.IsNull (state, "view ViewState not null");
 137
 138                         view.DeleteParameters.Add (p1);
 139                         view.InsertParameters.Add (p1);
 140                         //view.UpdateParameters.Add (p1);
 141
 142                         state = ((IStateManager) view).SaveViewState ();
 143                         Assert.IsNull (state, "view ViewState not null");
 144
 145                         view.FilterParameters.Add (p1);
 146                         //view.SelectParameters.Add (p1);
 147
 148                         state = ((IStateManager) view).SaveViewState ();
 149                         Assert.IsNotNull (state, "view ViewState not null");
 150
 151                         state = ((IStateManager) view.FilterParameters).SaveViewState ();
 152                         Assert.IsNotNull (state, "FilterParamenters ViewState not null");
 153                         state = ((IStateManager) view.SelectParameters).SaveViewState ();
 154                         Assert.IsNull (state, "SelectParameters ViewState not null");
 155
 156                         state = ((IStateManager) view.DeleteParameters).SaveViewState ();
 157                         Assert.IsNotNull (state, "DeleteParameters ViewState not null");
 158                         state = ((IStateManager) view.InsertParameters).SaveViewState ();
 159                         Assert.IsNotNull (state, "InsertParameters ViewState not null");
 160                         state = ((IStateManager) view.UpdateParameters).SaveViewState ();
 161                         Assert.IsNull (state, "UpdateParameters ViewState not null");
 162                 }\r
 163 \r
 164                 [Test]\r
 165                 public void ViewState ()\r
 166                 {\r
 167                         SqlDataSource ds = new SqlDataSource ();\r
 168                         SqlViewPoker sql = new SqlViewPoker (ds, "DefaultView", null);\r
 169 \r
 170                         /* XXX test parameters */\r
 171 \r
 172                         sql.CancelSelectOnNullParameter = false;\r
 173                         sql.ConflictDetection = ConflictOptions.CompareAllValues;\r
 174                         sql.DeleteCommandType = SqlDataSourceCommandType.Text;\r
 175                         sql.DeleteCommand = "delete command";\r
 176                         sql.FilterExpression = "filter expression";\r
 177                         sql.InsertCommand = "insert command";\r
 178                         sql.InsertCommandType = SqlDataSourceCommandType.Text;\r
 179                         sql.OldValuesParameterFormatString = "{1}";\r
 180                         sql.SelectCommand = "select command";\r
 181                         sql.SelectCommandType = SqlDataSourceCommandType.Text;\r
 182                         sql.SortParameterName = "sort parameter";\r
 183                         sql.UpdateCommand = "update command";\r
 184                         sql.UpdateCommandType = SqlDataSourceCommandType.Text;\r
 185 \r
 186                         Assert.IsFalse (sql.CancelSelectOnNullParameter, "A1");\r
 187                         Assert.AreEqual (ConflictOptions.CompareAllValues, sql.ConflictDetection, "A2");\r
 188                         Assert.AreEqual ("delete command", sql.DeleteCommand, "A3");\r
 189                         Assert.AreEqual (SqlDataSourceCommandType.Text, sql.DeleteCommandType, "A4");\r
 190                         Assert.AreEqual ("filter expression", sql.FilterExpression, "A5");\r
 191                         Assert.AreEqual ("insert command", sql.InsertCommand, "A6");\r
 192                         Assert.AreEqual (SqlDataSourceCommandType.Text, sql.InsertCommandType, "A7");\r
 193                         Assert.AreEqual ("{1}", sql.OldValuesParameterFormatString, "A8");\r
 194                         Assert.AreEqual ("select command", sql.SelectCommand, "A9");\r
 195                         Assert.AreEqual (SqlDataSourceCommandType.Text, sql.SelectCommandType, "A10");\r
 196                         Assert.AreEqual ("sort parameter", sql.SortParameterName, "A11");\r
 197                         Assert.AreEqual ("update command", sql.UpdateCommand, "A12");\r
 198                         Assert.AreEqual (SqlDataSourceCommandType.Text, sql.UpdateCommandType, "A13");\r
 199 \r
 200                         object state = sql.SaveToViewState ();\r
 201                         Assert.IsNull (state, "ViewState is null");\r
 202 \r
 203                         sql = new SqlViewPoker (ds, "DefaultView", null);\r
 204                         sql.LoadFromViewState (state);\r
 205 \r
 206                         Assert.IsTrue (sql.CancelSelectOnNullParameter, "B1");\r
 207                         Assert.IsFalse (sql.CanDelete, "B2");\r
 208                         Assert.IsFalse (sql.CanInsert, "B3");\r
 209                         Assert.IsFalse (sql.CanPage, "B4");\r
 210                         Assert.IsFalse (sql.CanRetrieveTotalRowCount, "B5");\r
 211                         Assert.IsTrue (sql.CanSort, "B6");\r
 212                         Assert.IsFalse (sql.CanUpdate, "B7");\r
 213                         Assert.AreEqual (ConflictOptions.OverwriteChanges, sql.ConflictDetection, "B8");\r
 214                         Assert.AreEqual ("", sql.DeleteCommand, "B9");\r
 215                         Assert.AreEqual (SqlDataSourceCommandType.Text, sql.DeleteCommandType, "B10");\r
 216                         Assert.IsNotNull (sql.DeleteParameters, "B11");\r
 217                         Assert.AreEqual (0, sql.DeleteParameters.Count, "B12");\r
 218                         Assert.AreEqual ("", sql.FilterExpression, "B13");\r
 219                         Assert.IsNotNull (sql.FilterParameters, "B14");\r
 220                         Assert.AreEqual (0, sql.FilterParameters.Count, "B15");\r
 221                         Assert.AreEqual ("", sql.InsertCommand, "B16");\r
 222                         Assert.AreEqual (SqlDataSourceCommandType.Text, sql.InsertCommandType, "B17");\r
 223                         Assert.IsNotNull (sql.InsertParameters, "B18");\r
 224                         Assert.AreEqual (0, sql.InsertParameters.Count, "B19");\r
 225                         Assert.AreEqual ("{0}", sql.OldValuesParameterFormatString, "B20");\r
 226                         Assert.AreEqual ("", sql.SelectCommand, "B21");\r
 227                         Assert.AreEqual (SqlDataSourceCommandType.Text, sql.SelectCommandType, "B22");\r
 228                         Assert.IsNotNull (sql.SelectParameters, "B23");\r
 229                         Assert.AreEqual (0, sql.SelectParameters.Count, "B24");\r
 230                         Assert.AreEqual ("", sql.SortParameterName, "B25");\r
 231                         Assert.AreEqual ("", sql.UpdateCommand, "B26");\r
 232                         Assert.AreEqual (SqlDataSourceCommandType.Text, sql.UpdateCommandType, "B27");\r
 233                         Assert.IsNotNull (sql.UpdateParameters, "B28");\r
 234                         Assert.AreEqual (0, sql.UpdateParameters.Count, "B29");\r
 235                 }\r
 236 \r
 237                 #region help_results\r
 238                 class eventAssert\r
 239                 {\r
 240                         private static int _testcounter;\r
 241                         private static bool _eventChecker;\r
 242                         private eventAssert ()\r
 243                         {\r
 244                                 _testcounter = 0;\r
 245                         }\r
 246 \r
 247                         public static bool eventChecker\r
 248                         {\r
 249                                 get\r
 250                                 {\r
 251                                         throw new NotImplementedException ();\r
 252                                 }\r
 253                                 set\r
 254                                 {\r
 255                                         _eventChecker = value;\r
 256                                 }\r
 257                         }\r
 258 \r
 259                         static private void testAdded ()\r
 260                         {\r
 261                                 _testcounter++;\r
 262                                 _eventChecker = false;\r
 263                         }\r
 264 \r
 265                         public static void IsTrue (string msg)\r
 266                         {\r
 267                                 Assert.IsTrue (_eventChecker, msg + "#" + _testcounter);\r
 268                                 testAdded ();\r
 269 \r
 270                         }\r
 271 \r
 272                         public static void IsFalse (string msg)\r
 273                         {\r
 274                                 Assert.IsFalse (_eventChecker, msg + "#" + _testcounter);\r
 275                                 testAdded ();\r
 276                         }\r
 277                 }\r
 278                 #endregion\r
 279 \r
 280                 [Test]\r
 281                 [Category ("NotWorking")]\r
 282                 public void SqlDataSourceView_DataSourceViewChanged ()\r
 283                 {\r
 284                         SqlDataSource ds = new SqlDataSource ();\r
 285                         SqlViewPoker sql = new SqlViewPoker (ds, "DefaultView", null);\r
 286                         sql.DataSourceViewChanged += new EventHandler (sql_DataSourceViewChanged);\r
 287                         sql.DoOnDataSourceViewChanged ();\r
 288                         eventAssert.IsTrue ("SqlDataSourceView"); // Assert include counter the first is zero\r
 289                         /* XXX test parameters */\r
 290 \r
 291                         sql.CancelSelectOnNullParameter = false;\r
 292                         eventAssert.IsTrue ("SqlDataSourceView");\r
 293                         sql.ConflictDetection = ConflictOptions.CompareAllValues;\r
 294                         eventAssert.IsTrue ("SqlDataSourceView");\r
 295                         sql.DeleteCommandType = SqlDataSourceCommandType.Text;\r
 296                         eventAssert.IsFalse ("SqlDataSourceView");\r
 297                         sql.DeleteCommand = "delete command";\r
 298                         eventAssert.IsFalse ("SqlDataSourceView");\r
 299                         sql.FilterExpression = "filter expression";\r
 300                         eventAssert.IsTrue ("SqlDataSourceView");\r
 301                         sql.InsertCommand = "insert command";\r
 302                         eventAssert.IsFalse ("SqlDataSourceView");\r
 303                         sql.InsertCommandType = SqlDataSourceCommandType.Text;\r
 304                         eventAssert.IsFalse ("SqlDataSourceView");\r
 305                         sql.OldValuesParameterFormatString = "{1}";\r
 306                         eventAssert.IsTrue ("SqlDataSourceView");\r
 307                         sql.SelectCommand = "select command";\r
 308                         eventAssert.IsTrue ("SqlDataSourceView");\r
 309                         sql.SelectCommandType = SqlDataSourceCommandType.Text;\r
 310                         eventAssert.IsFalse ("SqlDataSourceView");\r
 311                         sql.SortParameterName = "sort parameter";\r
 312                         eventAssert.IsTrue ("SqlDataSourceView");\r
 313                         sql.UpdateCommand = "update command";\r
 314                         eventAssert.IsFalse ("SqlDataSourceView");\r
 315                         sql.UpdateCommandType = SqlDataSourceCommandType.Text;\r
 316                         eventAssert.IsFalse ("SqlDataSourceView");\r
 317                 }\r
 318 \r
 319                 void sql_DataSourceViewChanged (object sender, EventArgs e)\r
 320                 {\r
 321                         eventAssert.eventChecker = true;\r
 322                 }\r
 323
 324                 [Test]
 325                 public void CanDelete ()
 326                 {
 327                         SqlDataSource ds = new SqlDataSource ();
 328                         SqlViewPoker sql = new SqlViewPoker (ds, "DefaultView", null);
 329
 330                         sql.DeleteCommand = "DELETE from foo";
 331                         Assert.IsTrue (sql.CanDelete, "A1");
 332
 333                         sql.DeleteCommand = "";
 334                         Assert.IsFalse (sql.CanDelete, "A2");
 335
 336                         sql.DeleteCommand = null;
 337                         Assert.IsFalse (sql.CanDelete, "A3");
 338                 }
 339
 340                 [Test]
 341                 public void CanInsert ()
 342                 {
 343                         SqlDataSource ds = new SqlDataSource ();
 344                         SqlViewPoker sql = new SqlViewPoker (ds, "DefaultView", null);
 345
 346                         sql.InsertCommand = "INSERT into foo";
 347                         Assert.IsTrue (sql.CanInsert, "A1");
 348
 349                         sql.InsertCommand = "";
 350                         Assert.IsFalse (sql.CanInsert, "A2");
 351
 352                         sql.InsertCommand = null;
 353                         Assert.IsFalse (sql.CanInsert, "A3");
 354                 }
 355
 356                 [Test]
 357                 public void CanUpdate ()
 358                 {
 359                         SqlDataSource ds = new SqlDataSource ();
 360                         SqlViewPoker sql = new SqlViewPoker (ds, "DefaultView", null);
 361
 362                         sql.UpdateCommand = "UPDATE foo";
 363                         Assert.IsTrue (sql.CanUpdate, "A1");
 364
 365                         sql.UpdateCommand = "";
 366                         Assert.IsFalse (sql.CanUpdate, "A2");
 367
 368                         sql.UpdateCommand = null;
 369                         Assert.IsFalse (sql.CanUpdate, "A3");
 370                 }
 371
 372                 [Test]
 373                 public void CanSort ()
 374                 {
 375                         SqlDataSource ds = new SqlDataSource ();
 376                         SqlViewPoker sql = new SqlViewPoker (ds, "DefaultView", null);
 377
 378                         sql.SortParameterName = "foo";
 379                         Assert.IsTrue (sql.CanSort, "A1");
 380
 381                         sql.SortParameterName = null;
 382                         Assert.IsTrue (sql.CanSort, "A2");
 383
 384                         sql.SortParameterName = "";
 385                         Assert.IsTrue (sql.CanSort, "A3");
 386
 387                         sql.SortParameterName = "foo";
 388
 389                         ds.DataSourceMode = SqlDataSourceMode.DataReader;
 390                         Assert.IsTrue (sql.CanSort, "A4");
 391
 392                         ds.DataSourceMode = SqlDataSourceMode.DataSet;
 393                         Assert.IsTrue (sql.CanSort, "A5");
 394
 395                         sql.SortParameterName = "";
 396
 397                         ds.DataSourceMode = SqlDataSourceMode.DataReader;
 398                         Assert.IsFalse (sql.CanSort, "A6");
 399
 400                         ds.DataSourceMode = SqlDataSourceMode.DataSet;
 401                         Assert.IsTrue (sql.CanSort, "A7");
 402                 }
 403
 404                 [Test]
 405                 public void OldValuesParameterFormatString ()
 406                 {
 407                         SqlDataSource ds = new SqlDataSource ();
 408
 409                         Assert.AreEqual ("{0}", ds.OldValuesParameterFormatString, "A1");
 410
 411                         ds.OldValuesParameterFormatString = "hi {0}";
 412
 413                         SqlViewPoker sql = new SqlViewPoker (ds, "DefaultView", null);
 414
 415                         Assert.AreEqual ("{0}", sql.OldValuesParameterFormatString, "A2");
 416
 417                         ds.OldValuesParameterFormatString = "hi {0}";
 418
 419                         Assert.AreEqual ("{0}", sql.OldValuesParameterFormatString, "A3");
 420
 421                         ds.OldValuesParameterFormatString = "{0}";
 422                         sql.OldValuesParameterFormatString = "hi {0}";
 423
 424                         Assert.AreEqual ("{0}", ds.OldValuesParameterFormatString, "A4");
 425                 }
 426
 427                 [Test]
 428                 public void CancelSelectOnNullParameter ()
 429                 {
 430                         SqlDataSource ds = new SqlDataSource ();
 431
 432                         ds.CancelSelectOnNullParameter = false;
 433
 434                         SqlViewPoker sql = new SqlViewPoker (ds, "DefaultView", null);
 435
 436                         Assert.IsTrue (sql.CancelSelectOnNullParameter, "A1");
 437
 438                         ds.CancelSelectOnNullParameter = true;
 439                         sql.CancelSelectOnNullParameter = false;
 440
 441                         Assert.IsTrue (ds.CancelSelectOnNullParameter, "A2");
 442
 443                         sql.CancelSelectOnNullParameter = false;
 444                         ds.CancelSelectOnNullParameter = true;
 445                         Assert.IsFalse (sql.CancelSelectOnNullParameter, "A3");
 446                 }
 447
 448                 public class AlwaysChangingParameter : Parameter
 449                 {
 450                         int evaluateCount;
 451
 452                         public AlwaysChangingParameter (string name, TypeCode type, string defaultValue)
 453                                 : base (name, type, defaultValue) {
 454                                 evaluateCount = 0;
 455                         }
 456
 457                         protected override object Evaluate (HttpContext context, Control control) {
 458                                 evaluateCount++;
 459                                 return String.Format ("{0}{1}", DefaultValue, evaluateCount);
 460                         }
 461                 }
 462
 463                 enum InitViewType
 464                 {
 465                         MatchParamsToValues,
 466                         MatchParamsToOldValues,
 467                         DontMatchParams,
 468                 }
 469
 470                 [Test]
 471                 public void SelectCommand_DataSourceViewChanged2 ()
 472                 {
 473                         SqlDataSource ds = new SqlDataSource ();
 474                         SqlViewPoker view = new SqlViewPoker (ds, "DefaultView", null);
 475                         view.DataSourceViewChanged += new EventHandler (view_DataSourceViewChanged);
 476
 477                         Assert.AreEqual ("", view.SelectCommand);
 478                         view.SelectCommand = null;
 479                         Assert.AreEqual (1, eventsCalled.Count);
 480                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [0]);
 481                         Assert.AreEqual ("", view.SelectCommand);
 482
 483                         view.SelectCommand = null;
 484                         Assert.AreEqual (2, eventsCalled.Count);
 485                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [1]);
 486                         Assert.AreEqual ("", view.SelectCommand);
 487
 488                         view.SelectCommand = "";
 489                         Assert.AreEqual (2, eventsCalled.Count);
 490                 }
 491
 492                 [Test]
 493                 public void SelectCommand_DataSourceViewChanged1 ()
 494                 {
 495                         SqlDataSource ds = new SqlDataSource ();
 496                         SqlViewPoker view = new SqlViewPoker (ds, "DefaultView", null);
 497                         view.DataSourceViewChanged+=new EventHandler(view_DataSourceViewChanged);
 498
 499                         view.SelectCommand = "select 1";
 500                         Assert.AreEqual (1, eventsCalled.Count);
 501                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled[0]);
 502
 503                         view.SelectCommand = "select 2";
 504                         Assert.AreEqual (2, eventsCalled.Count);
 505                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [1]);
 506
 507                         view.SelectCommand = "select 2";
 508                         Assert.AreEqual (2, eventsCalled.Count);
 509
 510                         view.SelectCommandType = SqlDataSourceCommandType.StoredProcedure;
 511                         Assert.AreEqual (2, eventsCalled.Count);
 512
 513                         view.SelectCommandType = SqlDataSourceCommandType.Text;
 514                         Assert.AreEqual (2, eventsCalled.Count);
 515                 }
 516
 517                 private static SqlViewPoker InitializeView (InitViewType initType, ConflictOptions conflictDetection, out Hashtable keys, out Hashtable old_value, out Hashtable new_value)
 518                 {
 519                         SqlDataSource ds = new SqlDataSource ();
 520                         ds.ConnectionString = "Data Source=fake\\SQLEXPRESS;Initial Catalog=Northwind;User ID=sa";
 521                         ds.ProviderName = "System.Data.SqlClient";
 522                         SqlViewPoker view = new SqlViewPoker (ds, "DefaultView", null);
 523
 524                         view.ConflictDetection = conflictDetection;
 525                         view.OldValuesParameterFormatString = "oldvalue_{0}";
 526                         view.SelectCommandType = SqlDataSourceCommandType.Text;
 527                         view.InsertCommandType = SqlDataSourceCommandType.Text;
 528                         view.UpdateCommandType = SqlDataSourceCommandType.Text;
 529                         view.DeleteCommandType = SqlDataSourceCommandType.Text;
 530
 531                         view.SelectCommand = "SELECT * FROM Customers WHERE ID = @ID";
 532                         view.InsertCommand = "INSERT INTO Customers (ID) VALUES (@ID)";
 533                         view.UpdateCommand = "UPDATE Customers SET ID = @ID WHERE ID = @oldvalue_ID";
 534                         view.DeleteCommand = "DELETE * FROM Customers WHERE ID = @ID";
 535
 536                         Parameter selectParameter = null;
 537                         Parameter insertParameter = null;
 538                         Parameter updateParameter = null;
 539                         Parameter deleteParameter = null;
 540
 541                         selectParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueSelect");
 542                         view.SelectParameters.Add (selectParameter);
 543
 544                         switch (initType) {
 545                         case InitViewType.MatchParamsToOldValues:
 546                                 insertParameter = new AlwaysChangingParameter ("oldvalue_ID", TypeCode.String, "p_OldValueInsert");
 547                                 view.InsertParameters.Add (insertParameter);
 548                                 updateParameter = new AlwaysChangingParameter ("oldvalue_ID", TypeCode.String, "p_OldValueUpdate");
 549                                 view.UpdateParameters.Add (updateParameter);
 550                                 deleteParameter = new AlwaysChangingParameter ("oldvalue_ID", TypeCode.String, "p_OldValueDelete");
 551                                 view.DeleteParameters.Add (deleteParameter);
 552                                 break;
 553
 554                         case InitViewType.MatchParamsToValues:
 555                                 insertParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueInsert");
 556                                 view.InsertParameters.Add (insertParameter);
 557                                 updateParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueUpdate");
 558                                 view.UpdateParameters.Add (updateParameter);
 559                                 deleteParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueDelete");
 560                                 view.DeleteParameters.Add (deleteParameter);
 561                                 break;
 562
 563                         case InitViewType.DontMatchParams:
 564                                 insertParameter = new AlwaysChangingParameter ("OtherValue", TypeCode.String, "p_OtherValueInsert");
 565                                 view.InsertParameters.Add (insertParameter);
 566                                 updateParameter = new AlwaysChangingParameter ("OtherValue", TypeCode.String, "p_OtherValueUpdate");
 567                                 view.UpdateParameters.Add (updateParameter);
 568                                 deleteParameter = new AlwaysChangingParameter ("OtherValue", TypeCode.String, "p_OtherValueDelete");
 569                                 view.DeleteParameters.Add (deleteParameter);
 570                                 break;
 571                         }
 572
 573                         view.SelectParameters.ParametersChanged += new EventHandler (SelectParameters_ParametersChanged);
 574                         view.InsertParameters.ParametersChanged += new EventHandler (InsertParameters_ParametersChanged);
 575                         view.UpdateParameters.ParametersChanged += new EventHandler (UpdateParameters_ParametersChanged);
 576                         view.DeleteParameters.ParametersChanged += new EventHandler (DeleteParameters_ParametersChanged);
 577
 578                         keys = new Hashtable ();
 579                         keys.Add ("ID", "k_1001");
 580
 581                         old_value = new Hashtable ();
 582                         old_value.Add ("ID", "ov_1001");
 583
 584                         new_value = new Hashtable ();
 585                         new_value.Add ("ID", "n_1001");
 586
 587                         view.DataSourceViewChanged += new EventHandler (view_DataSourceViewChanged);
 588
 589                         view.Selecting += new SqlDataSourceSelectingEventHandler (view_Selecting);
 590                         view.Inserting += new SqlDataSourceCommandEventHandler (view_Inserting);
 591                         view.Updating += new SqlDataSourceCommandEventHandler (view_Updating);
 592                         view.Deleting += new SqlDataSourceCommandEventHandler (view_Deleting);
 593                         return view;
 594                 }
 595
 596                 static void view_Selecting (object source, SqlDataSourceSelectingEventArgs e)
 597                 {
 598                         if (eventsCalled == null) {
 599                                 eventsCalled = new ArrayList ();
 600                         }
 601                         eventsCalled.Add (e.Arguments.ToString ());
 602                         eventsCalled.Add ("view_Selecting");
 603                         eventsCalled.Add (FormatParameters ((SqlParameterCollection)e.Command.Parameters));
 604                         e.Cancel = true;
 605                 }
 606
 607                 static void view_Inserting (object source, SqlDataSourceCommandEventArgs e)
 608                 {
 609                         if (eventsCalled == null) {
 610                                 eventsCalled = new ArrayList ();
 611                         }
 612                         eventsCalled.Add ("view_Inserting");
 613                         eventsCalled.Add (FormatParameters ((SqlParameterCollection) e.Command.Parameters));
 614                         e.Cancel = true;
 615                 }
 616
 617                 static void view_Updating (object source, SqlDataSourceCommandEventArgs e)
 618                 {
 619                         if (eventsCalled == null) {
 620                                 eventsCalled = new ArrayList ();
 621                         }
 622                         eventsCalled.Add ("view_Updating");
 623                         eventsCalled.Add (FormatParameters ((SqlParameterCollection) e.Command.Parameters));
 624                         e.Cancel = true;
 625                 }
 626
 627                 static void view_Deleting (object source, SqlDataSourceCommandEventArgs e)
 628                 {
 629                         if (eventsCalled == null) {
 630                                 eventsCalled = new ArrayList ();
 631                         }
 632                         eventsCalled.Add ("view_Deleting");
 633                         eventsCalled.Add (FormatParameters ((SqlParameterCollection) e.Command.Parameters));
 634                         e.Cancel = true;
 635                 }
 636
 637                 private static string FormatParameters (SqlParameterCollection sqlParameterCollection)
 638                 {
 639                         StringBuilder sb = new StringBuilder ();
 640                         foreach (SqlParameter p in sqlParameterCollection) {
 641                                 if (sb.Length > 0) {
 642                                         sb.Append (", ");
 643                                 }
 644                                 sb.AppendFormat ("{0}:{1}={2}", p.DbType, p.ParameterName, p.Value);
 645                         }
 646                         return sb.ToString ();
 647                 }
 648
 649                 private static IList eventsCalled;
 650
 651                 static void view_DataSourceViewChanged (object sender, EventArgs e)
 652                 {
 653                         if (eventsCalled == null) {
 654                                 eventsCalled = new ArrayList ();
 655                         }
 656                         eventsCalled.Add ("view_DataSourceViewChanged");
 657                 }
 658
 659                 static void SelectParameters_ParametersChanged (object sender, EventArgs e)
 660                 {
 661                         if (eventsCalled == null) {
 662                                 eventsCalled = new ArrayList ();
 663                         }
 664                         eventsCalled.Add ("SelectParameters_ParametersChanged");
 665                 }
 666
 667                 static void InsertParameters_ParametersChanged (object sender, EventArgs e)
 668                 {
 669                         if (eventsCalled == null) {
 670                                 eventsCalled = new ArrayList ();
 671                         }
 672                         eventsCalled.Add ("InsertParameters_ParametersChanged");
 673                 }
 674
 675                 static void UpdateParameters_ParametersChanged (object sender, EventArgs e)
 676                 {
 677                         if (eventsCalled == null) {
 678                                 eventsCalled = new ArrayList ();
 679                         }
 680                         eventsCalled.Add ("UpdateParameters_ParametersChanged");
 681                 }
 682
 683                 static void DeleteParameters_ParametersChanged (object sender, EventArgs e)
 684                 {
 685                         if (eventsCalled == null) {
 686                                 eventsCalled = new ArrayList ();
 687                         }
 688                         eventsCalled.Add ("DeleteParameters_ParametersChanged");
 689                 }
 690
 691                 [Test]
 692                 public void ParametersAndViewChangedEvent_Select ()
 693                 {
 694                         Hashtable keys = null;
 695                         Hashtable old_values = null;
 696                         Hashtable new_values = null;
 697                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
 698
 699                         view.Select (DataSourceSelectArguments.Empty);
 700
 701                         Assert.IsNotNull (eventsCalled, "Events not raized");
 702                         Assert.AreEqual (5, eventsCalled.Count, "Events Count");
 703                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [0], "view_DataSourceViewChanged");
 704                         Assert.AreEqual ("SelectParameters_ParametersChanged", eventsCalled [1], "SelectParameters_ParametersChanged");
 705                         Assert.AreEqual ("System.Web.UI.DataSourceSelectArguments", eventsCalled [2], "DataSourceSelectArguments");
 706                         Assert.AreEqual ("view_Selecting", eventsCalled [3], "view_Selecting");
 707                         string [] expectedParams = new string []
 708                                                 {
 709                                                         "String:@ID=p_ValueSelect1"
 710                                                 };
 711                         string [] actualValues = ((string)eventsCalled [4]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 712                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_Select Params count");
 713                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_Select expecte '{0}'");
 714                 }
 715
 716                 [Test]
 717                 public void ParametersAndViewChangedEvent_MatchInsert ()
 718                 {
 719                         Hashtable keys = null;
 720                         Hashtable old_values = null;
 721                         Hashtable new_values = null;
 722                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
 723
 724                         view.Insert (new_values);
 725
 726                         Assert.IsNotNull (eventsCalled, "Events not raized");
 727                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 728                         Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
 729                         Assert.AreEqual ("view_Inserting", eventsCalled [1], "view_Inserting");
 730                         string [] expectedParams = new string []
 731                                                 {
 732                                                         "String:@ID=n_1001"
 733                                                 };
 734                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 735                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchInsert Params count");
 736                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchInsert expecte '{0}'");
 737                 }
 738
 739                 [Test]
 740                 public void ParametersAndViewChangedEvent_MatchInsertAllValues ()
 741                 {
 742                         Hashtable keys = null;
 743                         Hashtable old_values = null;
 744                         Hashtable new_values = null;
 745                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.CompareAllValues, out keys, out old_values, out new_values);
 746
 747                         view.Insert (new_values);
 748
 749                         Assert.IsNotNull (eventsCalled, "Events not raized");
 750                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 751                         Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
 752                         Assert.AreEqual ("view_Inserting", eventsCalled [1], "view_Inserting");
 753                         string [] expectedParams = new string []
 754                                                 {
 755                                                         "String:@ID=n_1001"
 756                                                 };
 757                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 758                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchInsert Params count");
 759                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchInsert expecte '{0}'");
 760                 }
 761
 762                 [Test]
 763                 public void ParametersAndViewChangedEvent_MatchOldInsert ()
 764                 {
 765                         Hashtable keys = null;
 766                         Hashtable old_values = null;
 767                         Hashtable new_values = null;
 768                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToOldValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
 769
 770                         view.Insert (new_values);
 771
 772                         Assert.IsNotNull (eventsCalled, "Events not raized");
 773                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 774                         Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
 775                         Assert.AreEqual ("view_Inserting", eventsCalled [1], "view_Inserting");
 776                         string [] expectedParams = new string []
 777                                                 {
 778                                                         "String:@oldvalue_ID=p_OldValueInsert1",
 779                                                         "String:@ID=n_1001"
 780                                                 };
 781                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 782                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchOldInsert Params count");
 783                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchOldInsert expecte '{0}'");
 784                 }
 785
 786                 [Test]
 787                 public void ParametersAndViewChangedEvent_MatchOldInsertAllValues ()
 788                 {
 789                         Hashtable keys = null;
 790                         Hashtable old_values = null;
 791                         Hashtable new_values = null;
 792                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToOldValues, ConflictOptions.CompareAllValues, out keys, out old_values, out new_values);
 793
 794                         view.Insert (new_values);
 795
 796                         Assert.IsNotNull (eventsCalled, "Events not raized");
 797                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 798                         Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
 799                         Assert.AreEqual ("view_Inserting", eventsCalled [1], "view_Inserting");
 800                         string [] expectedParams = new string []
 801                                                 {
 802                                                         "String:@oldvalue_ID=p_OldValueInsert1",
 803                                                         "String:@ID=n_1001"
 804                                                 };
 805                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 806                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchOldInsert Params count");
 807                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchOldInsert expecte '{0}'");
 808                 }
 809
 810                 [Test]
 811                 public void ParametersAndViewChangedEvent_DontMatchInsert ()
 812                 {
 813                         Hashtable keys = null;
 814                         Hashtable old_values = null;
 815                         Hashtable new_values = null;
 816                         SqlViewPoker view = InitializeView (InitViewType.DontMatchParams, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
 817
 818                         view.Insert (new_values);
 819
 820                         Assert.IsNotNull (eventsCalled, "Events not raized");
 821                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 822                         Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
 823                         Assert.AreEqual ("view_Inserting", eventsCalled [1], "view_Inserting");
 824                         string [] expectedParams = new string []
 825                                                 {
 826                                                         "String:@OtherValue=p_OtherValueInsert1",
 827                                                         "String:@ID=n_1001"
 828                                                 };
 829                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 830                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_DontMatchInsert Params count");
 831                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_DontMatchInsert expecte '{0}'");
 832                 }
 833
 834                 [Test]
 835                 public void ParametersAndViewChangedEvent_MatchUpdate ()
 836                 {
 837                         Hashtable keys = null;
 838                         Hashtable old_values = null;
 839                         Hashtable new_values = null;
 840                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
 841
 842                         view.Update (keys, new_values, old_values);
 843
 844                         Assert.IsNotNull (eventsCalled, "Events not raized");
 845                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 846                         Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
 847                         Assert.AreEqual ("view_Updating", eventsCalled [1], "view_Updating");
 848                         string [] expectedParams = new string []
 849                                                 {
 850                                                         "String:@oldvalue_ID=k_1001",
 851                                                         "String:@ID=n_1001"
 852                                                 };
 853                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 854                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchUpdate Params count");
 855                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchUpdate expecte '{0}'");
 856                 }
 857
 858                 [Test]
 859                 public void ParametersAndViewChangedEvent_MatchUpdateAllValues ()
 860                 {
 861                         Hashtable keys = null;
 862                         Hashtable old_values = null;
 863                         Hashtable new_values = null;
 864                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.CompareAllValues, out keys, out old_values, out new_values);
 865
 866                         view.Update (keys, new_values, old_values);
 867
 868                         Assert.IsNotNull (eventsCalled, "Events not raized");
 869                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 870                         Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
 871                         Assert.AreEqual ("view_Updating", eventsCalled [1], "view_Updating");
 872                         string [] expectedParams = new string []
 873                                                 {
 874                                                         "String:@oldvalue_ID=ov_1001",
 875                                                         "String:@ID=n_1001"
 876                                                 };
 877                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 878                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchUpdate Params count");
 879                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchUpdate expecte '{0}'");
 880                 }
 881
 882                 [Test]
 883                 public void ParametersAndViewChangedEvent_MatchOldUpdate ()
 884                 {
 885                         Hashtable keys = null;
 886                         Hashtable old_values = null;
 887                         Hashtable new_values = null;
 888                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToOldValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
 889
 890                         view.Update (keys, new_values, old_values);
 891
 892                         Assert.IsNotNull (eventsCalled, "Events not raized");
 893                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 894                         Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
 895                         Assert.AreEqual ("view_Updating", eventsCalled [1], "view_Updating");
 896                         string [] expectedParams = new string []
 897                                                 {
 898                                                         "String:@oldvalue_ID=k_1001",
 899                                                         "String:@ID=n_1001"
 900                                                 };
 901                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 902                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchUpdate Params count");
 903                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchUpdate expecte '{0}'");
 904                 }
 905
 906                 [Test]
 907                 public void ParametersAndViewChangedEvent_MatchOldUpdateAllValues ()
 908                 {
 909                         Hashtable keys = null;
 910                         Hashtable old_values = null;
 911                         Hashtable new_values = null;
 912                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToOldValues, ConflictOptions.CompareAllValues, out keys, out old_values, out new_values);
 913
 914                         view.Update (keys, new_values, old_values);
 915
 916                         Assert.IsNotNull (eventsCalled, "Events not raized");
 917                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 918                         Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
 919                         Assert.AreEqual ("view_Updating", eventsCalled [1], "view_Updating");
 920                         string [] expectedParams = new string []
 921                                                 {
 922                                                         "String:@oldvalue_ID=ov_1001",
 923                                                         "String:@ID=n_1001"
 924                                                 };
 925                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 926                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchUpdate Params count");
 927                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchUpdate expecte '{0}'");
 928                 }
 929
 930                 [Test]
 931                 public void ParametersAndViewChangedEvent_DontMatchUpdate ()
 932                 {
 933                         Hashtable keys = null;
 934                         Hashtable old_values = null;
 935                         Hashtable new_values = null;
 936                         SqlViewPoker view = InitializeView (InitViewType.DontMatchParams, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
 937
 938                         view.Update (keys, new_values, old_values);
 939
 940                         Assert.IsNotNull (eventsCalled, "Events not raized");
 941                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 942                         Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
 943                         Assert.AreEqual ("view_Updating", eventsCalled [1], "view_Updating");
 944                         string [] expectedParams = new string []
 945                                                 {
 946                                                         "String:@oldvalue_ID=k_1001",
 947                                                         "String:@ID=n_1001",
 948                                                         "String:@OtherValue=p_OtherValueUpdate1"
 949                                                 };
 950                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 951                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_DontMatchUpdate Params count");
 952                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_DontMatchUpdate expecte '{0}'");
 953                 }
 954
 955                 [Test]
 956                 public void ParametersAndViewChangedEvent_MatchDelete ()
 957                 {
 958                         Hashtable keys = null;
 959                         Hashtable old_values = null;
 960                         Hashtable new_values = null;
 961                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
 962
 963                         view.Delete (keys, old_values);
 964
 965                         Assert.IsNotNull (eventsCalled, "Events not raized");
 966                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 967                         Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
 968                         Assert.AreEqual ("view_Deleting", eventsCalled [1], "view_Deleting");
 969                         string [] expectedParams = new string []
 970                                                 {
 971                                                         "String:@oldvalue_ID=k_1001",
 972                                                 };
 973                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 974                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchDelete Params count");
 975                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchDelete expecte '{0}'");
 976                 }
 977
 978                 [Test]
 979                 public void ParametersAndViewChangedEvent_MatchDeleteAllValues ()
 980                 {
 981                         Hashtable keys = null;
 982                         Hashtable old_values = null;
 983                         Hashtable new_values = null;
 984                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.CompareAllValues, out keys, out old_values, out new_values);
 985
 986                         view.Delete (keys, old_values);
 987
 988                         Assert.IsNotNull (eventsCalled, "Events not raized");
 989                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 990                         Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
 991                         Assert.AreEqual ("view_Deleting", eventsCalled [1], "view_Deleting");
 992                         string [] expectedParams = new string []
 993                                                 {
 994                                                         "String:@oldvalue_ID=ov_1001",
 995                                                 };
 996                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 997                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchDelete Params count");
 998                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchDelete expecte '{0}'");
 999                 }
1000
1001                 [Test]
1002                 public void ParametersAndViewChangedEvent_MatchOldDelete ()
1003                 {
1004                         Hashtable keys = null;
1005                         Hashtable old_values = null;
1006                         Hashtable new_values = null;
1007                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToOldValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
1008
1009                         view.Delete (keys, old_values);
1010
1011                         Assert.IsNotNull (eventsCalled, "Events not raized");
1012                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1013                         Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
1014                         Assert.AreEqual ("view_Deleting", eventsCalled [1], "view_Deleting");
1015                         string [] expectedParams = new string []
1016                                                 {
1017                                                         "String:@oldvalue_ID=k_1001",
1018                                                 };
1019                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
1020                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchOldDelete Params count");
1021                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchOldDelete expecte '{0}'");
1022                 }
1023
1024                 [Test]
1025                 public void ParametersAndViewChangedEvent_MatchOldDeleteAllValues ()
1026                 {
1027                         Hashtable keys = null;
1028                         Hashtable old_values = null;
1029                         Hashtable new_values = null;
1030                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToOldValues, ConflictOptions.CompareAllValues, out keys, out old_values, out new_values);
1031
1032                         view.Delete (keys, old_values);
1033
1034                         Assert.IsNotNull (eventsCalled, "Events not raized");
1035                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1036                         Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
1037                         Assert.AreEqual ("view_Deleting", eventsCalled [1], "view_Deleting");
1038                         string [] expectedParams = new string []
1039                                                 {
1040                                                         "String:@oldvalue_ID=ov_1001",
1041                                                 };
1042                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
1043                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchOldDelete Params count");
1044                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchOldDelete expecte '{0}'");
1045                 }
1046
1047                 [Test]
1048                 public void ParametersAndViewChangedEvent_DontMatchDelete ()
1049                 {
1050                         Hashtable keys = null;
1051                         Hashtable old_values = null;
1052                         Hashtable new_values = null;
1053                         SqlViewPoker view = InitializeView (InitViewType.DontMatchParams, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
1054
1055                         view.Delete (keys, old_values);
1056
1057                         Assert.IsNotNull (eventsCalled, "Events not raized");
1058                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1059                         Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
1060                         Assert.AreEqual ("view_Deleting", eventsCalled [1], "view_Deleting");
1061                         string [] expectedParams = new string []
1062                                                 {
1063                                                         "String:@oldvalue_ID=k_1001",
1064                                                         "String:@OtherValue=p_OtherValueDelete1"
1065                                                 };
1066                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
1067                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchOldDelete Params count");
1068                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchOldDelete expecte '{0}'");
1069                 }
1070
1071                 private static void ValidatePassedParams (string [] expectedParams, string [] actualValues, string errorMessageFormat)
1072                 {
1073                         foreach (string eps in expectedParams) {
1074                                 bool found = false;
1075                                 foreach (string aps in actualValues) {
1076                                         if (eps == aps) {
1077                                                 found = true;
1078                                                 break;
1079                                         }
1080                                 }
1081                                 Assert.IsTrue (found, String.Format (errorMessageFormat, eps));
1082                         }
1083                 }
1084         }
1085
1086 }
1087
1088 #endif