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

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