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