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                         internal
 456                         protected override object Evaluate (HttpContext context, Control control) {
 457                                 evaluateCount++;
 458                                 return String.Format ("{0}{1}", DefaultValue, evaluateCount);
 459                         }
 460                 }
 461
 462                 enum InitViewType
 463                 {
 464                         MatchParamsToValues,
 465                         MatchParamsToOldValues,
 466                         DontMatchParams,
 467                 }
 468
 469                 [Test]
 470                 public void SelectCommand_DataSourceViewChanged2 ()
 471                 {
 472                         SqlDataSource ds = new SqlDataSource ();
 473                         SqlViewPoker view = new SqlViewPoker (ds, "DefaultView", null);
 474                         view.DataSourceViewChanged += new EventHandler (view_DataSourceViewChanged);
 475
 476                         Assert.AreEqual ("", view.SelectCommand);
 477                         view.SelectCommand = null;
 478                         Assert.AreEqual (1, eventsCalled.Count);
 479                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [0]);
 480                         Assert.AreEqual ("", view.SelectCommand);
 481
 482                         view.SelectCommand = null;
 483                         Assert.AreEqual (2, eventsCalled.Count);
 484                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [1]);
 485                         Assert.AreEqual ("", view.SelectCommand);
 486
 487                         view.SelectCommand = "";
 488                         Assert.AreEqual (2, eventsCalled.Count);
 489                 }
 490
 491                 [Test]
 492                 public void SelectCommand_DataSourceViewChanged1 ()
 493                 {
 494                         SqlDataSource ds = new SqlDataSource ();
 495                         SqlViewPoker view = new SqlViewPoker (ds, "DefaultView", null);
 496                         view.DataSourceViewChanged+=new EventHandler(view_DataSourceViewChanged);
 497
 498                         view.SelectCommand = "select 1";
 499                         Assert.AreEqual (1, eventsCalled.Count);
 500                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled[0]);
 501
 502                         view.SelectCommand = "select 2";
 503                         Assert.AreEqual (2, eventsCalled.Count);
 504                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [1]);
 505
 506                         view.SelectCommand = "select 2";
 507                         Assert.AreEqual (2, eventsCalled.Count);
 508
 509                         view.SelectCommandType = SqlDataSourceCommandType.StoredProcedure;
 510                         Assert.AreEqual (2, eventsCalled.Count);
 511
 512                         view.SelectCommandType = SqlDataSourceCommandType.Text;
 513                         Assert.AreEqual (2, eventsCalled.Count);
 514                 }
 515
 516                 private static SqlViewPoker InitializeView (InitViewType initType, ConflictOptions conflictDetection, out Hashtable keys, out Hashtable old_value, out Hashtable new_value)
 517                 {
 518                         SqlDataSource ds = new SqlDataSource ();
 519                         ds.ConnectionString = "Data Source=fake\\SQLEXPRESS;Initial Catalog=Northwind;User ID=sa";
 520                         ds.ProviderName = "System.Data.SqlClient";
 521                         SqlViewPoker view = new SqlViewPoker (ds, "DefaultView", null);
 522
 523                         view.ConflictDetection = conflictDetection;
 524                         view.OldValuesParameterFormatString = "oldvalue_{0}";
 525                         view.SelectCommandType = SqlDataSourceCommandType.Text;
 526                         view.InsertCommandType = SqlDataSourceCommandType.Text;
 527                         view.UpdateCommandType = SqlDataSourceCommandType.Text;
 528                         view.DeleteCommandType = SqlDataSourceCommandType.Text;
 529
 530                         view.SelectCommand = "SELECT * FROM Customers WHERE ID = @ID";
 531                         view.InsertCommand = "INSERT INTO Customers (ID) VALUES (@ID)";
 532                         view.UpdateCommand = "UPDATE Customers SET ID = @ID WHERE ID = @oldvalue_ID";
 533                         view.DeleteCommand = "DELETE * FROM Customers WHERE ID = @ID";
 534
 535                         Parameter selectParameter = null;
 536                         Parameter insertParameter = null;
 537                         Parameter updateParameter = null;
 538                         Parameter deleteParameter = null;
 539
 540                         selectParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueSelect");
 541                         view.SelectParameters.Add (selectParameter);
 542
 543                         switch (initType) {
 544                         case InitViewType.MatchParamsToOldValues:
 545                                 insertParameter = new AlwaysChangingParameter ("oldvalue_ID", TypeCode.String, "p_OldValueInsert");
 546                                 view.InsertParameters.Add (insertParameter);
 547                                 updateParameter = new AlwaysChangingParameter ("oldvalue_ID", TypeCode.String, "p_OldValueUpdate");
 548                                 view.UpdateParameters.Add (updateParameter);
 549                                 deleteParameter = new AlwaysChangingParameter ("oldvalue_ID", TypeCode.String, "p_OldValueDelete");
 550                                 view.DeleteParameters.Add (deleteParameter);
 551                                 break;
 552
 553                         case InitViewType.MatchParamsToValues:
 554                                 insertParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueInsert");
 555                                 view.InsertParameters.Add (insertParameter);
 556                                 updateParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueUpdate");
 557                                 view.UpdateParameters.Add (updateParameter);
 558                                 deleteParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueDelete");
 559                                 view.DeleteParameters.Add (deleteParameter);
 560                                 break;
 561
 562                         case InitViewType.DontMatchParams:
 563                                 insertParameter = new AlwaysChangingParameter ("OtherValue", TypeCode.String, "p_OtherValueInsert");
 564                                 view.InsertParameters.Add (insertParameter);
 565                                 updateParameter = new AlwaysChangingParameter ("OtherValue", TypeCode.String, "p_OtherValueUpdate");
 566                                 view.UpdateParameters.Add (updateParameter);
 567                                 deleteParameter = new AlwaysChangingParameter ("OtherValue", TypeCode.String, "p_OtherValueDelete");
 568                                 view.DeleteParameters.Add (deleteParameter);
 569                                 break;
 570                         }
 571
 572                         view.SelectParameters.ParametersChanged += new EventHandler (SelectParameters_ParametersChanged);
 573                         view.InsertParameters.ParametersChanged += new EventHandler (InsertParameters_ParametersChanged);
 574                         view.UpdateParameters.ParametersChanged += new EventHandler (UpdateParameters_ParametersChanged);
 575                         view.DeleteParameters.ParametersChanged += new EventHandler (DeleteParameters_ParametersChanged);
 576
 577                         keys = new Hashtable ();
 578                         keys.Add ("ID", "k_1001");
 579
 580                         old_value = new Hashtable ();
 581                         old_value.Add ("ID", "ov_1001");
 582
 583                         new_value = new Hashtable ();
 584                         new_value.Add ("ID", "n_1001");
 585
 586                         view.DataSourceViewChanged += new EventHandler (view_DataSourceViewChanged);
 587
 588                         view.Selecting += new SqlDataSourceSelectingEventHandler (view_Selecting);
 589                         view.Inserting += new SqlDataSourceCommandEventHandler (view_Inserting);
 590                         view.Updating += new SqlDataSourceCommandEventHandler (view_Updating);
 591                         view.Deleting += new SqlDataSourceCommandEventHandler (view_Deleting);
 592                         return view;
 593                 }
 594
 595                 static void view_Selecting (object source, SqlDataSourceSelectingEventArgs e)
 596                 {
 597                         if (eventsCalled == null) {
 598                                 eventsCalled = new ArrayList ();
 599                         }
 600                         eventsCalled.Add (e.Arguments.ToString ());
 601                         eventsCalled.Add ("view_Selecting");
 602                         eventsCalled.Add (FormatParameters ((SqlParameterCollection)e.Command.Parameters));
 603                         e.Cancel = true;
 604                 }
 605
 606                 static void view_Inserting (object source, SqlDataSourceCommandEventArgs e)
 607                 {
 608                         if (eventsCalled == null) {
 609                                 eventsCalled = new ArrayList ();
 610                         }
 611                         eventsCalled.Add ("view_Inserting");
 612                         eventsCalled.Add (FormatParameters ((SqlParameterCollection) e.Command.Parameters));
 613                         e.Cancel = true;
 614                 }
 615
 616                 static void view_Updating (object source, SqlDataSourceCommandEventArgs e)
 617                 {
 618                         if (eventsCalled == null) {
 619                                 eventsCalled = new ArrayList ();
 620                         }
 621                         eventsCalled.Add ("view_Updating");
 622                         eventsCalled.Add (FormatParameters ((SqlParameterCollection) e.Command.Parameters));
 623                         e.Cancel = true;
 624                 }
 625
 626                 static void view_Deleting (object source, SqlDataSourceCommandEventArgs e)
 627                 {
 628                         if (eventsCalled == null) {
 629                                 eventsCalled = new ArrayList ();
 630                         }
 631                         eventsCalled.Add ("view_Deleting");
 632                         eventsCalled.Add (FormatParameters ((SqlParameterCollection) e.Command.Parameters));
 633                         e.Cancel = true;
 634                 }
 635
 636                 private static string FormatParameters (SqlParameterCollection sqlParameterCollection)
 637                 {
 638                         StringBuilder sb = new StringBuilder ();
 639                         foreach (SqlParameter p in sqlParameterCollection) {
 640                                 if (sb.Length > 0) {
 641                                         sb.Append (", ");
 642                                 }
 643                                 sb.AppendFormat ("{0}:{1}={2}", p.DbType, p.ParameterName, p.Value);
 644                         }
 645                         return sb.ToString ();
 646                 }
 647
 648                 private static IList eventsCalled;
 649
 650                 static void view_DataSourceViewChanged (object sender, EventArgs e)
 651                 {
 652                         if (eventsCalled == null) {
 653                                 eventsCalled = new ArrayList ();
 654                         }
 655                         eventsCalled.Add ("view_DataSourceViewChanged");
 656                 }
 657
 658                 static void SelectParameters_ParametersChanged (object sender, EventArgs e)
 659                 {
 660                         if (eventsCalled == null) {
 661                                 eventsCalled = new ArrayList ();
 662                         }
 663                         eventsCalled.Add ("SelectParameters_ParametersChanged");
 664                 }
 665
 666                 static void InsertParameters_ParametersChanged (object sender, EventArgs e)
 667                 {
 668                         if (eventsCalled == null) {
 669                                 eventsCalled = new ArrayList ();
 670                         }
 671                         eventsCalled.Add ("InsertParameters_ParametersChanged");
 672                 }
 673
 674                 static void UpdateParameters_ParametersChanged (object sender, EventArgs e)
 675                 {
 676                         if (eventsCalled == null) {
 677                                 eventsCalled = new ArrayList ();
 678                         }
 679                         eventsCalled.Add ("UpdateParameters_ParametersChanged");
 680                 }
 681
 682                 static void DeleteParameters_ParametersChanged (object sender, EventArgs e)
 683                 {
 684                         if (eventsCalled == null) {
 685                                 eventsCalled = new ArrayList ();
 686                         }
 687                         eventsCalled.Add ("DeleteParameters_ParametersChanged");
 688                 }
 689
 690                 [Test]
 691                 public void ParametersAndViewChangedEvent_Select ()
 692                 {
 693                         Hashtable keys = null;
 694                         Hashtable old_values = null;
 695                         Hashtable new_values = null;
 696                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
 697
 698                         view.Select (DataSourceSelectArguments.Empty);
 699
 700                         Assert.IsNotNull (eventsCalled, "Events not raized");
 701                         Assert.AreEqual (5, eventsCalled.Count, "Events Count");
 702                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [0], "view_DataSourceViewChanged");
 703                         Assert.AreEqual ("SelectParameters_ParametersChanged", eventsCalled [1], "SelectParameters_ParametersChanged");
 704                         Assert.AreEqual ("System.Web.UI.DataSourceSelectArguments", eventsCalled [2], "DataSourceSelectArguments");
 705                         Assert.AreEqual ("view_Selecting", eventsCalled [3], "view_Selecting");
 706                         string [] expectedParams = new string []
 707                                                 {
 708                                                         "String:@ID=p_ValueSelect1"
 709                                                 };
 710                         string [] actualValues = ((string)eventsCalled [4]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 711                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_Select Params count");
 712                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_Select expecte '{0}'");
 713                 }
 714
 715                 [Test]
 716                 public void ParametersAndViewChangedEvent_MatchInsert ()
 717                 {
 718                         Hashtable keys = null;
 719                         Hashtable old_values = null;
 720                         Hashtable new_values = null;
 721                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
 722
 723                         view.Insert (new_values);
 724
 725                         Assert.IsNotNull (eventsCalled, "Events not raized");
 726                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 727                         Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
 728                         Assert.AreEqual ("view_Inserting", eventsCalled [1], "view_Inserting");
 729                         string [] expectedParams = new string []
 730                                                 {
 731                                                         "String:@ID=n_1001"
 732                                                 };
 733                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 734                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchInsert Params count");
 735                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchInsert expecte '{0}'");
 736                 }
 737
 738                 [Test]
 739                 public void ParametersAndViewChangedEvent_MatchInsertAllValues ()
 740                 {
 741                         Hashtable keys = null;
 742                         Hashtable old_values = null;
 743                         Hashtable new_values = null;
 744                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.CompareAllValues, out keys, out old_values, out new_values);
 745
 746                         view.Insert (new_values);
 747
 748                         Assert.IsNotNull (eventsCalled, "Events not raized");
 749                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 750                         Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
 751                         Assert.AreEqual ("view_Inserting", eventsCalled [1], "view_Inserting");
 752                         string [] expectedParams = new string []
 753                                                 {
 754                                                         "String:@ID=n_1001"
 755                                                 };
 756                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 757                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchInsert Params count");
 758                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchInsert expecte '{0}'");
 759                 }
 760
 761                 [Test]
 762                 public void ParametersAndViewChangedEvent_MatchOldInsert ()
 763                 {
 764                         Hashtable keys = null;
 765                         Hashtable old_values = null;
 766                         Hashtable new_values = null;
 767                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToOldValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
 768
 769                         view.Insert (new_values);
 770
 771                         Assert.IsNotNull (eventsCalled, "Events not raized");
 772                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 773                         Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
 774                         Assert.AreEqual ("view_Inserting", eventsCalled [1], "view_Inserting");
 775                         string [] expectedParams = new string []
 776                                                 {
 777                                                         "String:@oldvalue_ID=p_OldValueInsert1",
 778                                                         "String:@ID=n_1001"
 779                                                 };
 780                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 781                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchOldInsert Params count");
 782                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchOldInsert expecte '{0}'");
 783                 }
 784
 785                 [Test]
 786                 public void ParametersAndViewChangedEvent_MatchOldInsertAllValues ()
 787                 {
 788                         Hashtable keys = null;
 789                         Hashtable old_values = null;
 790                         Hashtable new_values = null;
 791                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToOldValues, ConflictOptions.CompareAllValues, out keys, out old_values, out new_values);
 792
 793                         view.Insert (new_values);
 794
 795                         Assert.IsNotNull (eventsCalled, "Events not raized");
 796                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 797                         Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
 798                         Assert.AreEqual ("view_Inserting", eventsCalled [1], "view_Inserting");
 799                         string [] expectedParams = new string []
 800                                                 {
 801                                                         "String:@oldvalue_ID=p_OldValueInsert1",
 802                                                         "String:@ID=n_1001"
 803                                                 };
 804                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 805                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchOldInsert Params count");
 806                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchOldInsert expecte '{0}'");
 807                 }
 808
 809                 [Test]
 810                 public void ParametersAndViewChangedEvent_DontMatchInsert ()
 811                 {
 812                         Hashtable keys = null;
 813                         Hashtable old_values = null;
 814                         Hashtable new_values = null;
 815                         SqlViewPoker view = InitializeView (InitViewType.DontMatchParams, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
 816
 817                         view.Insert (new_values);
 818
 819                         Assert.IsNotNull (eventsCalled, "Events not raized");
 820                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 821                         Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
 822                         Assert.AreEqual ("view_Inserting", eventsCalled [1], "view_Inserting");
 823                         string [] expectedParams = new string []
 824                                                 {
 825                                                         "String:@OtherValue=p_OtherValueInsert1",
 826                                                         "String:@ID=n_1001"
 827                                                 };
 828                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 829                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_DontMatchInsert Params count");
 830                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_DontMatchInsert expecte '{0}'");
 831                 }
 832
 833                 [Test]
 834                 public void ParametersAndViewChangedEvent_MatchUpdate ()
 835                 {
 836                         Hashtable keys = null;
 837                         Hashtable old_values = null;
 838                         Hashtable new_values = null;
 839                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
 840
 841                         view.Update (keys, new_values, old_values);
 842
 843                         Assert.IsNotNull (eventsCalled, "Events not raized");
 844                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 845                         Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
 846                         Assert.AreEqual ("view_Updating", eventsCalled [1], "view_Updating");
 847                         string [] expectedParams = new string []
 848                                                 {
 849                                                         "String:@oldvalue_ID=k_1001",
 850                                                         "String:@ID=n_1001"
 851                                                 };
 852                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 853                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchUpdate Params count");
 854                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchUpdate expecte '{0}'");
 855                 }
 856
 857                 [Test]
 858                 public void ParametersAndViewChangedEvent_MatchUpdateAllValues ()
 859                 {
 860                         Hashtable keys = null;
 861                         Hashtable old_values = null;
 862                         Hashtable new_values = null;
 863                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.CompareAllValues, out keys, out old_values, out new_values);
 864
 865                         view.Update (keys, new_values, old_values);
 866
 867                         Assert.IsNotNull (eventsCalled, "Events not raized");
 868                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 869                         Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
 870                         Assert.AreEqual ("view_Updating", eventsCalled [1], "view_Updating");
 871                         string [] expectedParams = new string []
 872                                                 {
 873                                                         "String:@oldvalue_ID=ov_1001",
 874                                                         "String:@ID=n_1001"
 875                                                 };
 876                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 877                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchUpdate Params count");
 878                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchUpdate expecte '{0}'");
 879                 }
 880
 881                 [Test]
 882                 public void ParametersAndViewChangedEvent_MatchOldUpdate ()
 883                 {
 884                         Hashtable keys = null;
 885                         Hashtable old_values = null;
 886                         Hashtable new_values = null;
 887                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToOldValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
 888
 889                         view.Update (keys, new_values, old_values);
 890
 891                         Assert.IsNotNull (eventsCalled, "Events not raized");
 892                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 893                         Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
 894                         Assert.AreEqual ("view_Updating", eventsCalled [1], "view_Updating");
 895                         string [] expectedParams = new string []
 896                                                 {
 897                                                         "String:@oldvalue_ID=k_1001",
 898                                                         "String:@ID=n_1001"
 899                                                 };
 900                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 901                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchUpdate Params count");
 902                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchUpdate expecte '{0}'");
 903                 }
 904
 905                 [Test]
 906                 public void ParametersAndViewChangedEvent_MatchOldUpdateAllValues ()
 907                 {
 908                         Hashtable keys = null;
 909                         Hashtable old_values = null;
 910                         Hashtable new_values = null;
 911                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToOldValues, ConflictOptions.CompareAllValues, out keys, out old_values, out new_values);
 912
 913                         view.Update (keys, new_values, old_values);
 914
 915                         Assert.IsNotNull (eventsCalled, "Events not raized");
 916                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 917                         Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
 918                         Assert.AreEqual ("view_Updating", eventsCalled [1], "view_Updating");
 919                         string [] expectedParams = new string []
 920                                                 {
 921                                                         "String:@oldvalue_ID=ov_1001",
 922                                                         "String:@ID=n_1001"
 923                                                 };
 924                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 925                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchUpdate Params count");
 926                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchUpdate expecte '{0}'");
 927                 }
 928
 929                 [Test]
 930                 public void ParametersAndViewChangedEvent_DontMatchUpdate ()
 931                 {
 932                         Hashtable keys = null;
 933                         Hashtable old_values = null;
 934                         Hashtable new_values = null;
 935                         SqlViewPoker view = InitializeView (InitViewType.DontMatchParams, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
 936
 937                         view.Update (keys, new_values, old_values);
 938
 939                         Assert.IsNotNull (eventsCalled, "Events not raized");
 940                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 941                         Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
 942                         Assert.AreEqual ("view_Updating", eventsCalled [1], "view_Updating");
 943                         string [] expectedParams = new string []
 944                                                 {
 945                                                         "String:@oldvalue_ID=k_1001",
 946                                                         "String:@ID=n_1001",
 947                                                         "String:@OtherValue=p_OtherValueUpdate1"
 948                                                 };
 949                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 950                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_DontMatchUpdate Params count");
 951                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_DontMatchUpdate expecte '{0}'");
 952                 }
 953
 954                 [Test]
 955                 public void ParametersAndViewChangedEvent_MatchDelete ()
 956                 {
 957                         Hashtable keys = null;
 958                         Hashtable old_values = null;
 959                         Hashtable new_values = null;
 960                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
 961
 962                         view.Delete (keys, old_values);
 963
 964                         Assert.IsNotNull (eventsCalled, "Events not raized");
 965                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 966                         Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
 967                         Assert.AreEqual ("view_Deleting", eventsCalled [1], "view_Deleting");
 968                         string [] expectedParams = new string []
 969                                                 {
 970                                                         "String:@oldvalue_ID=k_1001",
 971                                                 };
 972                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 973                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchDelete Params count");
 974                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchDelete expecte '{0}'");
 975                 }
 976
 977                 [Test]
 978                 public void ParametersAndViewChangedEvent_MatchDeleteAllValues ()
 979                 {
 980                         Hashtable keys = null;
 981                         Hashtable old_values = null;
 982                         Hashtable new_values = null;
 983                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToValues, ConflictOptions.CompareAllValues, out keys, out old_values, out new_values);
 984
 985                         view.Delete (keys, old_values);
 986
 987                         Assert.IsNotNull (eventsCalled, "Events not raized");
 988                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
 989                         Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
 990                         Assert.AreEqual ("view_Deleting", eventsCalled [1], "view_Deleting");
 991                         string [] expectedParams = new string []
 992                                                 {
 993                                                         "String:@oldvalue_ID=ov_1001",
 994                                                 };
 995                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
 996                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchDelete Params count");
 997                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchDelete expecte '{0}'");
 998                 }
 999
1000                 [Test]
1001                 public void ParametersAndViewChangedEvent_MatchOldDelete ()
1002                 {
1003                         Hashtable keys = null;
1004                         Hashtable old_values = null;
1005                         Hashtable new_values = null;
1006                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToOldValues, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
1007
1008                         view.Delete (keys, old_values);
1009
1010                         Assert.IsNotNull (eventsCalled, "Events not raized");
1011                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1012                         Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
1013                         Assert.AreEqual ("view_Deleting", eventsCalled [1], "view_Deleting");
1014                         string [] expectedParams = new string []
1015                                                 {
1016                                                         "String:@oldvalue_ID=k_1001",
1017                                                 };
1018                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
1019                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchOldDelete Params count");
1020                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchOldDelete expecte '{0}'");
1021                 }
1022
1023                 [Test]
1024                 public void ParametersAndViewChangedEvent_MatchOldDeleteAllValues ()
1025                 {
1026                         Hashtable keys = null;
1027                         Hashtable old_values = null;
1028                         Hashtable new_values = null;
1029                         SqlViewPoker view = InitializeView (InitViewType.MatchParamsToOldValues, ConflictOptions.CompareAllValues, out keys, out old_values, out new_values);
1030
1031                         view.Delete (keys, old_values);
1032
1033                         Assert.IsNotNull (eventsCalled, "Events not raized");
1034                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1035                         Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
1036                         Assert.AreEqual ("view_Deleting", eventsCalled [1], "view_Deleting");
1037                         string [] expectedParams = new string []
1038                                                 {
1039                                                         "String:@oldvalue_ID=ov_1001",
1040                                                 };
1041                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
1042                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchOldDelete Params count");
1043                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchOldDelete expecte '{0}'");
1044                 }
1045
1046                 [Test]
1047                 public void ParametersAndViewChangedEvent_DontMatchDelete ()
1048                 {
1049                         Hashtable keys = null;
1050                         Hashtable old_values = null;
1051                         Hashtable new_values = null;
1052                         SqlViewPoker view = InitializeView (InitViewType.DontMatchParams, ConflictOptions.OverwriteChanges, out keys, out old_values, out new_values);
1053
1054                         view.Delete (keys, old_values);
1055
1056                         Assert.IsNotNull (eventsCalled, "Events not raized");
1057                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1058                         Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
1059                         Assert.AreEqual ("view_Deleting", eventsCalled [1], "view_Deleting");
1060                         string [] expectedParams = new string []
1061                                                 {
1062                                                         "String:@oldvalue_ID=k_1001",
1063                                                         "String:@OtherValue=p_OtherValueDelete1"
1064                                                 };
1065                         string [] actualValues = ((string) eventsCalled [2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
1066                         Assert.AreEqual (expectedParams.Length, actualValues.Length, "ParametersAndViewChangedEvent_MatchOldDelete Params count");
1067                         ValidatePassedParams (expectedParams, actualValues, "ParametersAndViewChangedEvent_MatchOldDelete expecte '{0}'");
1068                 }
1069
1070                 private static void ValidatePassedParams (string [] expectedParams, string [] actualValues, string errorMessageFormat)
1071                 {
1072                         foreach (string eps in expectedParams) {
1073                                 bool found = false;
1074                                 foreach (string aps in actualValues) {
1075                                         if (eps == aps) {
1076                                                 found = true;
1077                                                 break;
1078                                         }
1079                                 }
1080                                 Assert.IsTrue (found, String.Format (errorMessageFormat, eps));
1081                         }
1082                 }
1083         }
1084
1085 }
1086