Author: adar
Date: 2007-03-29 08:37:36 -0500 (Thu, 29 Mar 2007)
New Revision: 75137
Modified:
trunk/mcs/class/System.Web/System.Web.UI.WebControls/ChangeLog
trunk/mcs/class/System.Web/System.Web.UI.WebControls/ObjectDataSourceView.cs
trunk/mcs/class/System.Web/System.Web.UI.WebControls/SqlDataSourceView.cs
trunk/mcs/class/System.Web/Test/System.Web.UI.WebControls/ObjectDataSourceViewTest.cs
trunk/mcs/class/System.Web/Test/System.Web.UI.WebControls/SqlDataSourceViewTest.cs
Log:
2007-03-29 Adar Wesley <[EMAIL PROTECTED]>
* ObjectDataSourceView.cs: fixed events so they are raized at the
right times. Added many tests to verify the correct time.
* SqlDataSourceView.cs: fixed events so they are raized at the right
times. Added many tests to verify the correct time.
Modified: trunk/mcs/class/System.Web/System.Web.UI.WebControls/ChangeLog
===================================================================
--- trunk/mcs/class/System.Web/System.Web.UI.WebControls/ChangeLog
2007-03-29 13:24:34 UTC (rev 75136)
+++ trunk/mcs/class/System.Web/System.Web.UI.WebControls/ChangeLog
2007-03-29 13:37:36 UTC (rev 75137)
@@ -1,3 +1,10 @@
+2007-03-29 Adar Wesley <[EMAIL PROTECTED]>
+
+ * ObjectDataSourceView.cs: fixed events so they are raized at the
+ right times. Added many tests to verify the correct time.
+ * SqlDataSourceView.cs: fixed events so they are raized at the right
+ times. Added many tests to verify the correct time.
+
2007-03-28 Igor Zelmanovich <[EMAIL PROTECTED]>
* Menu.cs:
Modified:
trunk/mcs/class/System.Web/System.Web.UI.WebControls/ObjectDataSourceView.cs
===================================================================
---
trunk/mcs/class/System.Web/System.Web.UI.WebControls/ObjectDataSourceView.cs
2007-03-29 13:24:34 UTC (rev 75136)
+++
trunk/mcs/class/System.Web/System.Web.UI.WebControls/ObjectDataSourceView.cs
2007-03-29 13:37:36 UTC (rev 75137)
@@ -306,8 +306,8 @@
get {
return dataObjectTypeName != null ?
dataObjectTypeName : string.Empty;
}
- set {
- dataObjectTypeName = value;
+ set {
+ dataObjectTypeName = value;
dataObjectType = null;
}
}
@@ -531,7 +531,7 @@
Type DataObjectType {
get {
if (dataObjectType == null) {
- dataObjectType = LoadType
(DataObjectTypeName);
+ dataObjectType = LoadType
(DataObjectTypeName);
if (dataObjectType == null)
throw new
InvalidOperationException ("Type not found: " + DataObjectTypeName);
}
@@ -568,7 +568,7 @@
MethodInfo method;
if (DataObjectTypeName.Length == 0) {
- paramValues = MergeParameterValues
(InsertParameters, values, null, true);
+ paramValues = MergeParameterValues
(InsertParameters, values, null);
method = GetObjectMethod (InsertMethod,
paramValues, DataObjectMethodType.Insert);
} else {
method = ResolveDataObjectMethod (InsertMethod,
values, null, out paramValues);
@@ -608,7 +608,7 @@
MethodInfo method;
if (DataObjectTypeName.Length == 0) {
- paramValues = MergeParameterValues
(DeleteParameters, null, oldDataValues, true);
+ paramValues = MergeParameterValues
(DeleteParameters, null, oldDataValues);
method = GetObjectMethod (DeleteMethod,
paramValues, DataObjectMethodType.Delete);
} else {
method = ResolveDataObjectMethod (DeleteMethod,
oldDataValues, null, out paramValues);
@@ -646,7 +646,7 @@
{
IDictionary dataValues;
dataValues = values;
- paramValues = MergeParameterValues
(UpdateParameters, dataValues, oldDataValues, false);
+ paramValues = MergeParameterValues
(UpdateParameters, dataValues, oldDataValues);
method = GetObjectMethod (UpdateMethod,
paramValues, DataObjectMethodType.Update);
}
else
@@ -715,7 +715,7 @@
{
arguments.RaiseUnsupportedCapabilitiesError (this);
- IOrderedDictionary paramValues = MergeParameterValues
(SelectParameters, null, null, true);
+ IOrderedDictionary paramValues = MergeParameterValues
(SelectParameters, null, null);
ObjectDataSourceSelectingEventArgs args = new
ObjectDataSourceSelectingEventArgs (paramValues, arguments, false);
object result = null;
@@ -1026,33 +1026,27 @@
/// <param name="allwaysAddNewValues">true for insert, as
current item is
/// irrelevant for insert</param>
/// <returns>merged values</returns>
- IOrderedDictionary MergeParameterValues (ParameterCollection
viewParams, IDictionary values, IDictionary oldValues, bool allwaysAddNewValues)
+ IOrderedDictionary MergeParameterValues (ParameterCollection
viewParams, IDictionary values, IDictionary oldValues)
{
+ IOrderedDictionary parametersValues =
viewParams.GetValues (context, owner);
OrderedDictionary mergedValues = new OrderedDictionary
(StringComparer.InvariantCultureIgnoreCase);
- foreach (Parameter p in viewParams) {
- bool oldAdded = false;
+ foreach (string parameterName in parametersValues.Keys)
{
+ mergedValues [parameterName] = parametersValues
[parameterName];
if (oldValues != null) {
- object value = FindValueByName (p.Name,
oldValues, true);
+ object value = FindValueByName
(parameterName, oldValues, true);
if (value != null) {
- object dataValue =
p.ConvertValue (value);
- mergedValues [p.Name] =
dataValue;
- oldAdded = true;
+ object dataValue = viewParams
[parameterName].ConvertValue (value);
+ mergedValues [parameterName] =
dataValue;
}
}
- bool newAdded = false;
if (values != null) {
- object value = FindValueByName (p.Name,
values, false);
+ object value = FindValueByName
(parameterName, values, false);
if (value != null) {
- object dataValue =
p.ConvertValue (value);
- mergedValues [p.Name] =
dataValue;
- newAdded = true;
+ object dataValue = viewParams
[parameterName].ConvertValue (value);
+ mergedValues [parameterName] =
dataValue;
}
}
- if ((!newAdded && !oldAdded) ||
allwaysAddNewValues) {
- object val = p.GetValue (context,
owner);
- mergedValues [p.Name] = val;
- }
}
if (values != null) {
@@ -1062,9 +1056,11 @@
}
if (oldValues != null) {
- foreach (DictionaryEntry de in oldValues)
- if (FindValueByName ((string) de.Key,
mergedValues, true) == null)
- mergedValues
[FormatOldParameter ((string) de.Key)] = de.Value;
+ foreach (DictionaryEntry de in oldValues) {
+ string oldValueKey = FormatOldParameter
((string) de.Key);
+ if (FindValueByName (oldValueKey,
mergedValues, false) == null)
+ mergedValues [oldValueKey] =
de.Value;
+ }
}
return mergedValues;
@@ -1194,3 +1190,4 @@
+
Modified:
trunk/mcs/class/System.Web/System.Web.UI.WebControls/SqlDataSourceView.cs
===================================================================
--- trunk/mcs/class/System.Web/System.Web.UI.WebControls/SqlDataSourceView.cs
2007-03-29 13:24:34 UTC (rev 75136)
+++ trunk/mcs/class/System.Web/System.Web.UI.WebControls/SqlDataSourceView.cs
2007-03-29 13:37:36 UTC (rev 75137)
@@ -99,7 +99,7 @@
else
oldDataValues = keys;
- InitializeParameters (command, DeleteParameters, null,
oldDataValues, false);
+ InitializeParameters (command, DeleteParameters, null,
oldDataValues, true);
SqlDataSourceCommandEventArgs args = new
SqlDataSourceCommandEventArgs (command);
OnDeleting (args);
@@ -153,7 +153,7 @@
else
command.CommandType =
CommandType.StoredProcedure;
- InitializeParameters (command, InsertParameters,
values, null, true);
+ InitializeParameters (command, InsertParameters,
values, null, false);
SqlDataSourceCommandEventArgs args = new
SqlDataSourceCommandEventArgs (command);
OnInserting (args);
@@ -217,7 +217,7 @@
}
if (SelectParameters.Count > 0)
- InitializeParameters (command,
SelectParameters, null, null, true);
+ InitializeParameters (command,
SelectParameters, null, null, false);
Exception exception = null;
if (owner.DataSourceMode == SqlDataSourceMode.DataSet) {
@@ -344,7 +344,7 @@
IDictionary dataValues = values;
- InitializeParameters (command, UpdateParameters,
dataValues, oldDataValues, ConflictDetection ==
ConflictOptions.CompareAllValues);
+ InitializeParameters (command, UpdateParameters,
dataValues, oldDataValues, ConflictDetection ==
ConflictOptions.OverwriteChanges);
SqlDataSourceCommandEventArgs args = new
SqlDataSourceCommandEventArgs (command);
OnUpdating (args);
@@ -387,37 +387,46 @@
return name;
}
- object FindValueByName (Parameter p, IDictionary values, bool
format)
+ object FindValueByName (string parameterName, IDictionary
values, bool format)
{
if (values == null)
return null;
foreach (DictionaryEntry de in values) {
string valueName = format == true ?
FormatOldParameter (de.Key.ToString ()) : de.Key.ToString ();
- if (p.Name == valueName)
+ if (parameterName == valueName)
return values [de.Key];
}
foreach (DictionaryEntry de in values) {
string valueName = format == true ?
FormatOldParameter (de.Key.ToString ()) : de.Key.ToString ();
valueName = valueName.ToLower ();
- if (p.Name.ToLower () == valueName)
+ if (parameterName.ToLower () == valueName)
return values [de.Key];
}
return null;
}
- void InitializeParameters (DbCommand command,
ParameterCollection parameters, IDictionary values, IDictionary oldValues, bool
alwaysAddParameters)
+ void InitializeParameters (DbCommand command,
ParameterCollection parameters, IDictionary values, IDictionary oldValues, bool
parametersMayMatchOldValues)
{
- foreach (Parameter p in parameters) {
- object value = FindValueByName (p, values,
false);
- string valueName = p.Name;
+ IOrderedDictionary parameterValues =
parameters.GetValues (context, owner);
+
+ foreach (string parameterName in parameterValues.Keys) {
+ Parameter p = parameters [parameterName];
+ object value = FindValueByName (parameterName,
values, false);
+ string valueName = parameterName;
if (value == null)
- value = FindValueByName (p, oldValues,
true);
- if (value == null && !alwaysAddParameters) {
- value = FindValueByName (p, oldValues,
false);
- valueName = FormatOldParameter (p.Name);
+ value = FindValueByName (parameterName,
oldValues, true);
+
+ if (value == null &&
parametersMayMatchOldValues) {
+ value = FindValueByName (parameterName,
oldValues, false);
+ valueName = FormatOldParameter
(parameterName);
}
+ if (value == null) {
+ value = parameterValues [parameterName];
+ valueName = parameterName;
+ }
+
if (value != null) {
object dbValue = p.ConvertValue (value);
DbParameter newParameter =
CreateDbParameter (valueName, dbValue, p.Direction, p.Size);
@@ -425,10 +434,6 @@
command.Parameters.Add
(newParameter);
}
}
- else {
- object dbValue = p.GetValue (context,
owner);
- command.Parameters.Add
(CreateDbParameter (p.Name, dbValue, p.Direction, p.Size));
- }
}
if (values != null) {
@@ -860,3 +865,4 @@
}
#endif
+
Modified:
trunk/mcs/class/System.Web/Test/System.Web.UI.WebControls/ObjectDataSourceViewTest.cs
===================================================================
---
trunk/mcs/class/System.Web/Test/System.Web.UI.WebControls/ObjectDataSourceViewTest.cs
2007-03-29 13:24:34 UTC (rev 75136)
+++
trunk/mcs/class/System.Web/Test/System.Web.UI.WebControls/ObjectDataSourceViewTest.cs
2007-03-29 13:37:36 UTC (rev 75137)
@@ -61,7 +61,7 @@
TrackViewState ();
}
- public bool IsTrackingViewState ()
+ public bool GetIsTrackingViewState ()
{
return base.IsTrackingViewState;
}
@@ -153,6 +153,12 @@
WebTest.Unload ();
}
+ [SetUp()]
+ public void Setup ()
+ {
+ eventsCalled = null;
+ }
+
[Test]
public void Defaults ()
{
@@ -189,7 +195,7 @@
Assert.AreEqual ("startRowIndex",
sql.StartRowIndexParameterName, "StartRowIndexParameterName");
Assert.AreEqual ("", sql.TypeName, "TypeName");
Assert.AreEqual ("", sql.UpdateMethod, "UpdateMethod");
- Assert.AreEqual (true, sql.IsTrackingViewState (),
"IsTrackingViewState");
+ Assert.AreEqual (true, sql.GetIsTrackingViewState (),
"IsTrackingViewState");
Assert.IsTrue (sql.CanRetrieveTotalRowCount,
"CanRetrieveTotalRowCount");
}
@@ -388,7 +394,8 @@
}
[Test]
- public void CanRetrieveTotalRowCount () {
+ public void CanRetrieveTotalRowCount ()
+ {
ObjectDataSource ds = new ObjectDataSource ();
ObjectDataSourceView view = new ObjectDataSourceView
(ds, "DefaultView", null);
@@ -807,7 +814,415 @@
Eventassert ("ObjectDisposing");
}
+ enum InitViewType
+ {
+ MatchParamsToValues,
+ MatchParamsToOldValues,
+ DontMatchParams,
+ }
+ public class DummyDataSourceObject
+ {
+ public static IEnumerable Select (string filter)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add (String.Format ("Select(filter
= {0})", filter));
+ return new string [] { "one", "two", "three" };
+ }
+
+ public static int Update (string ID)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add (String.Format ("Update(ID =
{0})", ID));
+ return 1;
+ }
+
+ public static int Update (string ID, string
oldvalue_ID)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add (String.Format ("Update(ID =
{0}, oldvalue_ID = {1})", ID, oldvalue_ID));
+ return 1;
+ }
+
+ public static int UpdateOther (string ID, string
OtherValue, string oldvalue_ID)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add (String.Format
("UpdateOther(ID = {0}, OtherValue = {1}, oldvalue_ID = {2})", ID, OtherValue,
oldvalue_ID));
+ return 1;
+ }
+
+ public static int Insert (string ID)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add (String.Format ("Insert(ID =
{0})", ID));
+ return 1;
+ }
+
+ public static int Insert (string ID, string
oldvalue_ID)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add (String.Format ("Insert(ID =
{0}, oldvalue_ID = {1})", ID, oldvalue_ID));
+ return 1;
+ }
+
+ public static int InsertOther (string ID, string
OtherValue)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add (String.Format
("InsertOther(ID = {0}, OtherValue = {1})", ID, OtherValue));
+ return 1;
+ }
+
+ public static int Delete (string ID, string
oldvalue_ID)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add (String.Format ("Delete(ID =
{0}, oldvalue_ID = {1})", ID, oldvalue_ID));
+ return 1;
+ }
+
+ public static int Delete (string oldvalue_ID)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add (String.Format
("Delete(oldvalue_ID = {0})", oldvalue_ID));
+ return 1;
+ }
+
+ public static int DeleteOther (string oldvalue_ID,
string OtherValue)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add (String.Format
("DeleteOther(oldvalue_ID = {0}, OtherValue = {1})", oldvalue_ID, OtherValue));
+ return 1;
+ }
+ }
+
+ public class AlwaysChangingParameter : Parameter
+ {
+ int evaluateCount;
+
+ public AlwaysChangingParameter (string name, TypeCode
type, string defaultValue)
+ : base (name, type, defaultValue)
+ {
+ evaluateCount = 0;
+ }
+
+ protected override object Evaluate (HttpContext
context, Control control)
+ {
+ evaluateCount++;
+ return String.Format ("{0}{1}", DefaultValue,
evaluateCount);
+ }
+ }
+
+ private static void InitializeView (ObjectViewPoker view,
InitViewType initType, out Hashtable keys, out Hashtable old_value, out
Hashtable new_value)
+ {
+ view.TypeName = typeof
(DummyDataSourceObject).AssemblyQualifiedName;
+ view.OldValuesParameterFormatString = "oldvalue_{0}";
+ view.SelectMethod = "Select";
+ if (initType == InitViewType.DontMatchParams) {
+ view.UpdateMethod = "UpdateOther";
+ view.InsertMethod = "InsertOther";
+ view.DeleteMethod = "DeleteOther";
+ }
+ else {
+ view.UpdateMethod = "Update";
+ view.InsertMethod = "Insert";
+ view.DeleteMethod = "Delete";
+ }
+
+ Parameter selectParameter = null;
+ Parameter insertParameter = null;
+ Parameter updateParameter = null;
+ Parameter deleteParameter = null;
+
+ selectParameter = new AlwaysChangingParameter
("filter", TypeCode.String, "p_ValueSelect");
+ view.SelectParameters.Add (selectParameter);
+
+ switch (initType) {
+ case InitViewType.MatchParamsToOldValues:
+ insertParameter = new AlwaysChangingParameter
("oldvalue_ID", TypeCode.String, "p_OldValueInsert");
+ view.InsertParameters.Add (insertParameter);
+ updateParameter = new AlwaysChangingParameter
("oldvalue_ID", TypeCode.String, "p_OldValueUpdate");
+ view.UpdateParameters.Add (updateParameter);
+ deleteParameter = new AlwaysChangingParameter
("oldvalue_ID", TypeCode.String, "p_OldValueDelete");
+ view.DeleteParameters.Add (deleteParameter);
+ break;
+
+ case InitViewType.MatchParamsToValues:
+ insertParameter = new AlwaysChangingParameter
("ID", TypeCode.String, "p_ValueInsert");
+ view.InsertParameters.Add (insertParameter);
+ updateParameter = new AlwaysChangingParameter
("ID", TypeCode.String, "p_ValueUpdate");
+ view.UpdateParameters.Add (updateParameter);
+ deleteParameter = new AlwaysChangingParameter
("ID", TypeCode.String, "p_ValueDelete");
+ view.DeleteParameters.Add (deleteParameter);
+ break;
+
+ case InitViewType.DontMatchParams:
+ insertParameter = new AlwaysChangingParameter
("OtherValue", TypeCode.String, "p_OtherValueInsert");
+ view.InsertParameters.Add (insertParameter);
+ updateParameter = new AlwaysChangingParameter
("OtherValue", TypeCode.String, "p_OtherValueUpdate");
+ view.UpdateParameters.Add (updateParameter);
+ deleteParameter = new AlwaysChangingParameter
("OtherValue", TypeCode.String, "p_OtherValueDelete");
+ view.DeleteParameters.Add (deleteParameter);
+ break;
+ }
+
+ view.SelectParameters.ParametersChanged += new
EventHandler (SelectParameters_ParametersChanged);
+ view.InsertParameters.ParametersChanged += new
EventHandler (InsertParameters_ParametersChanged);
+ view.UpdateParameters.ParametersChanged += new
EventHandler (UpdateParameters_ParametersChanged);
+ view.DeleteParameters.ParametersChanged += new
EventHandler (DeleteParameters_ParametersChanged);
+
+ keys = new Hashtable ();
+ keys.Add ("ID", "k_1001");
+
+ old_value = new Hashtable ();
+ old_value.Add ("ID", "ov_1001");
+
+ new_value = new Hashtable ();
+ new_value.Add ("ID", "n_1001");
+
+ view.DataSourceViewChanged += new EventHandler
(view_DataSourceViewChanged);
+ }
+
+ private static IList eventsCalled;
+
+ static void view_DataSourceViewChanged (object sender,
EventArgs e)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add ("view_DataSourceViewChanged");
+ }
+
+ static void SelectParameters_ParametersChanged (object sender,
EventArgs e)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add ("SelectParameters_ParametersChanged");
+ }
+
+ static void InsertParameters_ParametersChanged (object sender,
EventArgs e)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add ("InsertParameters_ParametersChanged");
+ }
+
+ static void UpdateParameters_ParametersChanged (object sender,
EventArgs e)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add ("UpdateParameters_ParametersChanged");
+ }
+
+ static void DeleteParameters_ParametersChanged (object sender,
EventArgs e)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add ("DeleteParameters_ParametersChanged");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_Select ()
+ {
+ ObjectViewPoker view = new ObjectViewPoker (new
ObjectDataSource (), "", null);
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ InitializeView (view, InitViewType.MatchParamsToValues,
out keys, out old_values, out new_values);
+
+ view.Select (DataSourceSelectArguments.Empty);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("view_DataSourceViewChanged",
eventsCalled [0], "view_DataSourceViewChanged");
+ Assert.AreEqual ("SelectParameters_ParametersChanged",
eventsCalled [1], "SelectParameters_ParametersChanged");
+ Assert.AreEqual ("Select(filter = p_ValueSelect1)",
eventsCalled [2], "DataSource Method params");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_MatchInsert ()
+ {
+ ObjectViewPoker view = new ObjectViewPoker (new
ObjectDataSource (), "", null);
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ InitializeView (view, InitViewType.MatchParamsToValues,
out keys, out old_values, out new_values);
+
+ view.Insert (new_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("InsertParameters_ParametersChanged",
eventsCalled [0], "InsertParameters_ParametersChanged");
+ Assert.AreEqual ("Insert(ID = n_1001)", eventsCalled
[1], "DataSource Method params");
+ Assert.AreEqual ("view_DataSourceViewChanged",
eventsCalled [2], "view_DataSourceViewChanged");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_MatchOldInsert ()
+ {
+ ObjectViewPoker view = new ObjectViewPoker (new
ObjectDataSource (), "", null);
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ InitializeView (view,
InitViewType.MatchParamsToOldValues, out keys, out old_values, out new_values);
+
+ view.Insert (new_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("InsertParameters_ParametersChanged",
eventsCalled [0], "InsertParameters_ParametersChanged");
+ Assert.AreEqual ("Insert(ID = n_1001, oldvalue_ID =
p_OldValueInsert1)", eventsCalled [1], "DataSource Method params");
+ Assert.AreEqual ("view_DataSourceViewChanged",
eventsCalled [2], "view_DataSourceViewChanged");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_DontMatchInsert ()
+ {
+ ObjectViewPoker view = new ObjectViewPoker (new
ObjectDataSource (), "", null);
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ InitializeView (view, InitViewType.DontMatchParams, out
keys, out old_values, out new_values);
+
+ view.Insert (new_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("InsertParameters_ParametersChanged",
eventsCalled [0], "InsertParameters_ParametersChanged");
+ Assert.AreEqual ("InsertOther(ID = n_1001, OtherValue =
p_OtherValueInsert1)", eventsCalled [1], "DataSource Method params");
+ Assert.AreEqual ("view_DataSourceViewChanged",
eventsCalled [2], "view_DataSourceViewChanged");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_MatchUpdate ()
+ {
+ ObjectViewPoker view = new ObjectViewPoker (new
ObjectDataSource (), "", null);
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ InitializeView (view, InitViewType.MatchParamsToValues,
out keys, out old_values, out new_values);
+
+ view.Update (keys, new_values, old_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("UpdateParameters_ParametersChanged",
eventsCalled [0], "UpdateParameters_ParametersChanged");
+ Assert.AreEqual ("Update(ID = n_1001, oldvalue_ID =
k_1001)", eventsCalled [1], "DataSource Method params");
+ Assert.AreEqual ("view_DataSourceViewChanged",
eventsCalled [2], "view_DataSourceViewChanged");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_MatchOldUpdate ()
+ {
+ ObjectViewPoker view = new ObjectViewPoker (new
ObjectDataSource (), "", null);
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ InitializeView (view,
InitViewType.MatchParamsToOldValues, out keys, out old_values, out new_values);
+
+ view.Update (keys, new_values, old_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("UpdateParameters_ParametersChanged",
eventsCalled [0], "UpdateParameters_ParametersChanged");
+ Assert.AreEqual ("Update(ID = n_1001, oldvalue_ID =
k_1001)", eventsCalled [1], "DataSource Method params");
+ Assert.AreEqual ("view_DataSourceViewChanged",
eventsCalled [2], "view_DataSourceViewChanged");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_DontMatchUpdate ()
+ {
+ ObjectViewPoker view = new ObjectViewPoker (new
ObjectDataSource (), "", null);
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ InitializeView (view, InitViewType.DontMatchParams, out
keys, out old_values, out new_values);
+
+ view.Update (keys, new_values, old_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("UpdateParameters_ParametersChanged",
eventsCalled [0], "UpdateParameters_ParametersChanged");
+ Assert.AreEqual ("UpdateOther(ID = n_1001, OtherValue =
p_OtherValueUpdate1, oldvalue_ID = k_1001)", eventsCalled [1], "DataSource
Method params");
+ Assert.AreEqual ("view_DataSourceViewChanged",
eventsCalled [2], "view_DataSourceViewChanged");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_MatchDelete ()
+ {
+ ObjectViewPoker view = new ObjectViewPoker (new
ObjectDataSource (), "", null);
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ InitializeView (view, InitViewType.MatchParamsToValues,
out keys, out old_values, out new_values);
+
+ view.Delete (keys, old_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("DeleteParameters_ParametersChanged",
eventsCalled [0], "DeleteParameters_ParametersChanged");
+ Assert.AreEqual ("Delete(ID = p_ValueDelete1,
oldvalue_ID = k_1001)", eventsCalled [1], "DataSource Method params");
+ Assert.AreEqual ("view_DataSourceViewChanged",
eventsCalled [2], "view_DataSourceViewChanged");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_MatchOldDelete ()
+ {
+ ObjectViewPoker view = new ObjectViewPoker (new
ObjectDataSource (), "", null);
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ InitializeView (view,
InitViewType.MatchParamsToOldValues, out keys, out old_values, out new_values);
+
+ view.Delete (keys, old_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("DeleteParameters_ParametersChanged",
eventsCalled [0], "DeleteParameters_ParametersChanged");
+ Assert.AreEqual ("Delete(oldvalue_ID = k_1001)",
eventsCalled [1], "DataSource Method params");
+ Assert.AreEqual ("view_DataSourceViewChanged",
eventsCalled [2], "view_DataSourceViewChanged");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_DontMatchDelete ()
+ {
+ ObjectViewPoker view = new ObjectViewPoker (new
ObjectDataSource (), "", null);
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ InitializeView (view, InitViewType.DontMatchParams, out
keys, out old_values, out new_values);
+
+ view.Delete (keys, old_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("DeleteParameters_ParametersChanged",
eventsCalled [0], "DeleteParameters_ParametersChanged");
+ Assert.AreEqual ("DeleteOther(oldvalue_ID = k_1001,
OtherValue = p_OtherValueDelete1)", eventsCalled [1], "DataSource Method
params");
+ Assert.AreEqual ("view_DataSourceViewChanged",
eventsCalled [2], "view_DataSourceViewChanged");
+ }
+
/// <summary>
/// Helper methods
/// </summary>
Modified:
trunk/mcs/class/System.Web/Test/System.Web.UI.WebControls/SqlDataSourceViewTest.cs
===================================================================
---
trunk/mcs/class/System.Web/Test/System.Web.UI.WebControls/SqlDataSourceViewTest.cs
2007-03-29 13:24:34 UTC (rev 75136)
+++
trunk/mcs/class/System.Web/Test/System.Web.UI.WebControls/SqlDataSourceViewTest.cs
2007-03-29 13:37:36 UTC (rev 75137)
@@ -39,6 +39,9 @@
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
+using System.Collections;
+using System.Data.SqlClient;
+using System.Text;
namespace MonoTests.System.Web.UI.WebControls
{
@@ -63,6 +66,12 @@
[TestFixture]
public class SqlDataSourceViewTest
{
+ [SetUp]
+ public void Setup ()
+ {
+ eventsCalled = null;
+ }
+
[Test]
public void Defaults ()
{
@@ -343,6 +352,596 @@
ds.CancelSelectOnNullParameter = true;
Assert.IsFalse (sql.CancelSelectOnNullParameter, "A3");
}
+
+ public class AlwaysChangingParameter : Parameter
+ {
+ int evaluateCount;
+
+ public AlwaysChangingParameter (string name, TypeCode
type, string defaultValue)
+ : base (name, type, defaultValue) {
+ evaluateCount = 0;
+ }
+
+ protected override object Evaluate (HttpContext
context, Control control) {
+ evaluateCount++;
+ return String.Format ("{0}{1}", DefaultValue,
evaluateCount);
+ }
+ }
+
+ enum InitViewType
+ {
+ MatchParamsToValues,
+ MatchParamsToOldValues,
+ DontMatchParams,
+ }
+
+ private static SqlViewPoker InitializeView (InitViewType
initType, ConflictOptions conflictDetection, out Hashtable keys, out Hashtable
old_value, out Hashtable new_value)
+ {
+ SqlDataSource ds = new SqlDataSource ();
+ ds.ConnectionString = "Data
Source=fake\\SQLEXPRESS;Initial Catalog=Northwind;User ID=sa";
+ ds.ProviderName = "System.Data.SqlClient";
+ SqlViewPoker view = new SqlViewPoker (ds,
"DefaultView", null);
+
+ view.ConflictDetection = conflictDetection;
+ view.OldValuesParameterFormatString = "oldvalue_{0}";
+ view.SelectCommandType = SqlDataSourceCommandType.Text;
+ view.InsertCommandType = SqlDataSourceCommandType.Text;
+ view.UpdateCommandType = SqlDataSourceCommandType.Text;
+ view.DeleteCommandType = SqlDataSourceCommandType.Text;
+
+ view.SelectCommand = "SELECT * FROM Customers WHERE ID
= @ID";
+ view.InsertCommand = "INSERT INTO Customers (ID) VALUES
(@ID)";
+ view.UpdateCommand = "UPDATE Customers SET ID = @ID
WHERE ID = @oldvalue_ID";
+ view.DeleteCommand = "DELETE * FROM Customers WHERE ID
= @ID";
+
+ Parameter selectParameter = null;
+ Parameter insertParameter = null;
+ Parameter updateParameter = null;
+ Parameter deleteParameter = null;
+
+ selectParameter = new AlwaysChangingParameter ("ID",
TypeCode.String, "p_ValueSelect");
+ view.SelectParameters.Add (selectParameter);
+
+ switch (initType) {
+ case InitViewType.MatchParamsToOldValues:
+ insertParameter = new AlwaysChangingParameter
("oldvalue_ID", TypeCode.String, "p_OldValueInsert");
+ view.InsertParameters.Add (insertParameter);
+ updateParameter = new AlwaysChangingParameter
("oldvalue_ID", TypeCode.String, "p_OldValueUpdate");
+ view.UpdateParameters.Add (updateParameter);
+ deleteParameter = new AlwaysChangingParameter
("oldvalue_ID", TypeCode.String, "p_OldValueDelete");
+ view.DeleteParameters.Add (deleteParameter);
+ break;
+
+ case InitViewType.MatchParamsToValues:
+ insertParameter = new AlwaysChangingParameter
("ID", TypeCode.String, "p_ValueInsert");
+ view.InsertParameters.Add (insertParameter);
+ updateParameter = new AlwaysChangingParameter
("ID", TypeCode.String, "p_ValueUpdate");
+ view.UpdateParameters.Add (updateParameter);
+ deleteParameter = new AlwaysChangingParameter
("ID", TypeCode.String, "p_ValueDelete");
+ view.DeleteParameters.Add (deleteParameter);
+ break;
+
+ case InitViewType.DontMatchParams:
+ insertParameter = new AlwaysChangingParameter
("OtherValue", TypeCode.String, "p_OtherValueInsert");
+ view.InsertParameters.Add (insertParameter);
+ updateParameter = new AlwaysChangingParameter
("OtherValue", TypeCode.String, "p_OtherValueUpdate");
+ view.UpdateParameters.Add (updateParameter);
+ deleteParameter = new AlwaysChangingParameter
("OtherValue", TypeCode.String, "p_OtherValueDelete");
+ view.DeleteParameters.Add (deleteParameter);
+ break;
+ }
+
+ view.SelectParameters.ParametersChanged += new
EventHandler (SelectParameters_ParametersChanged);
+ view.InsertParameters.ParametersChanged += new
EventHandler (InsertParameters_ParametersChanged);
+ view.UpdateParameters.ParametersChanged += new
EventHandler (UpdateParameters_ParametersChanged);
+ view.DeleteParameters.ParametersChanged += new
EventHandler (DeleteParameters_ParametersChanged);
+
+ keys = new Hashtable ();
+ keys.Add ("ID", "k_1001");
+
+ old_value = new Hashtable ();
+ old_value.Add ("ID", "ov_1001");
+
+ new_value = new Hashtable ();
+ new_value.Add ("ID", "n_1001");
+
+ view.DataSourceViewChanged += new EventHandler
(view_DataSourceViewChanged);
+
+ view.Selecting += new
SqlDataSourceSelectingEventHandler (view_Selecting);
+ view.Inserting += new SqlDataSourceCommandEventHandler
(view_Inserting);
+ view.Updating += new SqlDataSourceCommandEventHandler
(view_Updating);
+ view.Deleting += new SqlDataSourceCommandEventHandler
(view_Deleting);
+ return view;
+ }
+
+ static void view_Selecting (object source,
SqlDataSourceSelectingEventArgs e)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add (e.Arguments.ToString ());
+ eventsCalled.Add ("view_Selecting");
+ eventsCalled.Add (FormatParameters
((SqlParameterCollection)e.Command.Parameters));
+ e.Cancel = true;
+ }
+
+ static void view_Inserting (object source,
SqlDataSourceCommandEventArgs e)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add ("view_Inserting");
+ eventsCalled.Add (FormatParameters
((SqlParameterCollection) e.Command.Parameters));
+ e.Cancel = true;
+ }
+
+ static void view_Updating (object source,
SqlDataSourceCommandEventArgs e)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add ("view_Updating");
+ eventsCalled.Add (FormatParameters
((SqlParameterCollection) e.Command.Parameters));
+ e.Cancel = true;
+ }
+
+ static void view_Deleting (object source,
SqlDataSourceCommandEventArgs e)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add ("view_Deleting");
+ eventsCalled.Add (FormatParameters
((SqlParameterCollection) e.Command.Parameters));
+ e.Cancel = true;
+ }
+
+ private static string FormatParameters (SqlParameterCollection
sqlParameterCollection)
+ {
+ StringBuilder sb = new StringBuilder ();
+ foreach (SqlParameter p in sqlParameterCollection) {
+ if (sb.Length > 0) {
+ sb.Append (", ");
+ }
+ sb.AppendFormat ("{0}:{1}={2}", p.DbType,
p.ParameterName, p.Value);
+ }
+ return sb.ToString ();
+ }
+
+ private static IList eventsCalled;
+
+ static void view_DataSourceViewChanged (object sender,
EventArgs e)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add ("view_DataSourceViewChanged");
+ }
+
+ static void SelectParameters_ParametersChanged (object sender,
EventArgs e)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add ("SelectParameters_ParametersChanged");
+ }
+
+ static void InsertParameters_ParametersChanged (object sender,
EventArgs e)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add ("InsertParameters_ParametersChanged");
+ }
+
+ static void UpdateParameters_ParametersChanged (object sender,
EventArgs e)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add ("UpdateParameters_ParametersChanged");
+ }
+
+ static void DeleteParameters_ParametersChanged (object sender,
EventArgs e)
+ {
+ if (eventsCalled == null) {
+ eventsCalled = new ArrayList ();
+ }
+ eventsCalled.Add ("DeleteParameters_ParametersChanged");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_Select ()
+ {
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ SqlViewPoker view = InitializeView
(InitViewType.MatchParamsToValues, ConflictOptions.OverwriteChanges, out keys,
out old_values, out new_values);
+
+ view.Select (DataSourceSelectArguments.Empty);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (5, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("view_DataSourceViewChanged",
eventsCalled [0], "view_DataSourceViewChanged");
+ Assert.AreEqual ("SelectParameters_ParametersChanged",
eventsCalled [1], "SelectParameters_ParametersChanged");
+ Assert.AreEqual
("System.Web.UI.DataSourceSelectArguments", eventsCalled [2],
"DataSourceSelectArguments");
+ Assert.AreEqual ("view_Selecting", eventsCalled [3],
"view_Selecting");
+ string [] expectedParams = new string []
+ {
+
"String:@ID=p_ValueSelect1"
+ };
+ string [] actualValues = ((string)eventsCalled
[4]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+ Assert.AreEqual (expectedParams.Length,
actualValues.Length, "ParametersAndViewChangedEvent_Select Params count");
+ ValidatePassedParams (expectedParams, actualValues,
"ParametersAndViewChangedEvent_Select expecte '{0}'");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_MatchInsert ()
+ {
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ SqlViewPoker view = InitializeView
(InitViewType.MatchParamsToValues, ConflictOptions.OverwriteChanges, out keys,
out old_values, out new_values);
+
+ view.Insert (new_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("InsertParameters_ParametersChanged",
eventsCalled [0], "InsertParameters_ParametersChanged");
+ Assert.AreEqual ("view_Inserting", eventsCalled [1],
"view_Inserting");
+ string [] expectedParams = new string []
+ {
+ "String:@ID=n_1001"
+ };
+ string [] actualValues = ((string) eventsCalled
[2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+ Assert.AreEqual (expectedParams.Length,
actualValues.Length, "ParametersAndViewChangedEvent_MatchInsert Params count");
+ ValidatePassedParams (expectedParams, actualValues,
"ParametersAndViewChangedEvent_MatchInsert expecte '{0}'");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_MatchInsertAllValues
()
+ {
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ SqlViewPoker view = InitializeView
(InitViewType.MatchParamsToValues, ConflictOptions.CompareAllValues, out keys,
out old_values, out new_values);
+
+ view.Insert (new_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("InsertParameters_ParametersChanged",
eventsCalled [0], "InsertParameters_ParametersChanged");
+ Assert.AreEqual ("view_Inserting", eventsCalled [1],
"view_Inserting");
+ string [] expectedParams = new string []
+ {
+ "String:@ID=n_1001"
+ };
+ string [] actualValues = ((string) eventsCalled
[2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+ Assert.AreEqual (expectedParams.Length,
actualValues.Length, "ParametersAndViewChangedEvent_MatchInsert Params count");
+ ValidatePassedParams (expectedParams, actualValues,
"ParametersAndViewChangedEvent_MatchInsert expecte '{0}'");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_MatchOldInsert ()
+ {
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ SqlViewPoker view = InitializeView
(InitViewType.MatchParamsToOldValues, ConflictOptions.OverwriteChanges, out
keys, out old_values, out new_values);
+
+ view.Insert (new_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("InsertParameters_ParametersChanged",
eventsCalled [0], "InsertParameters_ParametersChanged");
+ Assert.AreEqual ("view_Inserting", eventsCalled [1],
"view_Inserting");
+ string [] expectedParams = new string []
+ {
+
"String:@oldvalue_ID=p_OldValueInsert1",
+ "String:@ID=n_1001"
+ };
+ string [] actualValues = ((string) eventsCalled
[2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+ Assert.AreEqual (expectedParams.Length,
actualValues.Length, "ParametersAndViewChangedEvent_MatchOldInsert Params
count");
+ ValidatePassedParams (expectedParams, actualValues,
"ParametersAndViewChangedEvent_MatchOldInsert expecte '{0}'");
+ }
+
+ [Test]
+ public void
ParametersAndViewChangedEvent_MatchOldInsertAllValues ()
+ {
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ SqlViewPoker view = InitializeView
(InitViewType.MatchParamsToOldValues, ConflictOptions.CompareAllValues, out
keys, out old_values, out new_values);
+
+ view.Insert (new_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("InsertParameters_ParametersChanged",
eventsCalled [0], "InsertParameters_ParametersChanged");
+ Assert.AreEqual ("view_Inserting", eventsCalled [1],
"view_Inserting");
+ string [] expectedParams = new string []
+ {
+
"String:@oldvalue_ID=p_OldValueInsert1",
+ "String:@ID=n_1001"
+ };
+ string [] actualValues = ((string) eventsCalled
[2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+ Assert.AreEqual (expectedParams.Length,
actualValues.Length, "ParametersAndViewChangedEvent_MatchOldInsert Params
count");
+ ValidatePassedParams (expectedParams, actualValues,
"ParametersAndViewChangedEvent_MatchOldInsert expecte '{0}'");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_DontMatchInsert ()
+ {
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ SqlViewPoker view = InitializeView
(InitViewType.DontMatchParams, ConflictOptions.OverwriteChanges, out keys, out
old_values, out new_values);
+
+ view.Insert (new_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("InsertParameters_ParametersChanged",
eventsCalled [0], "InsertParameters_ParametersChanged");
+ Assert.AreEqual ("view_Inserting", eventsCalled [1],
"view_Inserting");
+ string [] expectedParams = new string []
+ {
+
"String:@OtherValue=p_OtherValueInsert1",
+ "String:@ID=n_1001"
+ };
+ string [] actualValues = ((string) eventsCalled
[2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+ Assert.AreEqual (expectedParams.Length,
actualValues.Length, "ParametersAndViewChangedEvent_DontMatchInsert Params
count");
+ ValidatePassedParams (expectedParams, actualValues,
"ParametersAndViewChangedEvent_DontMatchInsert expecte '{0}'");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_MatchUpdate ()
+ {
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ SqlViewPoker view = InitializeView
(InitViewType.MatchParamsToValues, ConflictOptions.OverwriteChanges, out keys,
out old_values, out new_values);
+
+ view.Update (keys, new_values, old_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("UpdateParameters_ParametersChanged",
eventsCalled [0], "UpdateParameters_ParametersChanged");
+ Assert.AreEqual ("view_Updating", eventsCalled [1],
"view_Updating");
+ string [] expectedParams = new string []
+ {
+
"String:@oldvalue_ID=k_1001",
+ "String:@ID=n_1001"
+ };
+ string [] actualValues = ((string) eventsCalled
[2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+ Assert.AreEqual (expectedParams.Length,
actualValues.Length, "ParametersAndViewChangedEvent_MatchUpdate Params count");
+ ValidatePassedParams (expectedParams, actualValues,
"ParametersAndViewChangedEvent_MatchUpdate expecte '{0}'");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_MatchUpdateAllValues
()
+ {
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ SqlViewPoker view = InitializeView
(InitViewType.MatchParamsToValues, ConflictOptions.CompareAllValues, out keys,
out old_values, out new_values);
+
+ view.Update (keys, new_values, old_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("UpdateParameters_ParametersChanged",
eventsCalled [0], "UpdateParameters_ParametersChanged");
+ Assert.AreEqual ("view_Updating", eventsCalled [1],
"view_Updating");
+ string [] expectedParams = new string []
+ {
+
"String:@oldvalue_ID=ov_1001",
+ "String:@ID=n_1001"
+ };
+ string [] actualValues = ((string) eventsCalled
[2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+ Assert.AreEqual (expectedParams.Length,
actualValues.Length, "ParametersAndViewChangedEvent_MatchUpdate Params count");
+ ValidatePassedParams (expectedParams, actualValues,
"ParametersAndViewChangedEvent_MatchUpdate expecte '{0}'");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_MatchOldUpdate ()
+ {
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ SqlViewPoker view = InitializeView
(InitViewType.MatchParamsToOldValues, ConflictOptions.OverwriteChanges, out
keys, out old_values, out new_values);
+
+ view.Update (keys, new_values, old_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("UpdateParameters_ParametersChanged",
eventsCalled [0], "UpdateParameters_ParametersChanged");
+ Assert.AreEqual ("view_Updating", eventsCalled [1],
"view_Updating");
+ string [] expectedParams = new string []
+ {
+
"String:@oldvalue_ID=k_1001",
+ "String:@ID=n_1001"
+ };
+ string [] actualValues = ((string) eventsCalled
[2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+ Assert.AreEqual (expectedParams.Length,
actualValues.Length, "ParametersAndViewChangedEvent_MatchUpdate Params count");
+ ValidatePassedParams (expectedParams, actualValues,
"ParametersAndViewChangedEvent_MatchUpdate expecte '{0}'");
+ }
+
+ [Test]
+ public void
ParametersAndViewChangedEvent_MatchOldUpdateAllValues ()
+ {
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ SqlViewPoker view = InitializeView
(InitViewType.MatchParamsToOldValues, ConflictOptions.CompareAllValues, out
keys, out old_values, out new_values);
+
+ view.Update (keys, new_values, old_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("UpdateParameters_ParametersChanged",
eventsCalled [0], "UpdateParameters_ParametersChanged");
+ Assert.AreEqual ("view_Updating", eventsCalled [1],
"view_Updating");
+ string [] expectedParams = new string []
+ {
+
"String:@oldvalue_ID=ov_1001",
+ "String:@ID=n_1001"
+ };
+ string [] actualValues = ((string) eventsCalled
[2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+ Assert.AreEqual (expectedParams.Length,
actualValues.Length, "ParametersAndViewChangedEvent_MatchUpdate Params count");
+ ValidatePassedParams (expectedParams, actualValues,
"ParametersAndViewChangedEvent_MatchUpdate expecte '{0}'");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_DontMatchUpdate ()
+ {
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ SqlViewPoker view = InitializeView
(InitViewType.DontMatchParams, ConflictOptions.OverwriteChanges, out keys, out
old_values, out new_values);
+
+ view.Update (keys, new_values, old_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("UpdateParameters_ParametersChanged",
eventsCalled [0], "UpdateParameters_ParametersChanged");
+ Assert.AreEqual ("view_Updating", eventsCalled [1],
"view_Updating");
+ string [] expectedParams = new string []
+ {
+
"String:@oldvalue_ID=k_1001",
+ "String:@ID=n_1001",
+
"String:@OtherValue=p_OtherValueUpdate1"
+ };
+ string [] actualValues = ((string) eventsCalled
[2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+ Assert.AreEqual (expectedParams.Length,
actualValues.Length, "ParametersAndViewChangedEvent_DontMatchUpdate Params
count");
+ ValidatePassedParams (expectedParams, actualValues,
"ParametersAndViewChangedEvent_DontMatchUpdate expecte '{0}'");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_MatchDelete ()
+ {
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ SqlViewPoker view = InitializeView
(InitViewType.MatchParamsToValues, ConflictOptions.OverwriteChanges, out keys,
out old_values, out new_values);
+
+ view.Delete (keys, old_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("DeleteParameters_ParametersChanged",
eventsCalled [0], "DeleteParameters_ParametersChanged");
+ Assert.AreEqual ("view_Deleting", eventsCalled [1],
"view_Deleting");
+ string [] expectedParams = new string []
+ {
+
"String:@oldvalue_ID=k_1001",
+ };
+ string [] actualValues = ((string) eventsCalled
[2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+ Assert.AreEqual (expectedParams.Length,
actualValues.Length, "ParametersAndViewChangedEvent_MatchDelete Params count");
+ ValidatePassedParams (expectedParams, actualValues,
"ParametersAndViewChangedEvent_MatchDelete expecte '{0}'");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_MatchDeleteAllValues
()
+ {
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ SqlViewPoker view = InitializeView
(InitViewType.MatchParamsToValues, ConflictOptions.CompareAllValues, out keys,
out old_values, out new_values);
+
+ view.Delete (keys, old_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("DeleteParameters_ParametersChanged",
eventsCalled [0], "DeleteParameters_ParametersChanged");
+ Assert.AreEqual ("view_Deleting", eventsCalled [1],
"view_Deleting");
+ string [] expectedParams = new string []
+ {
+
"String:@oldvalue_ID=ov_1001",
+ };
+ string [] actualValues = ((string) eventsCalled
[2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+ Assert.AreEqual (expectedParams.Length,
actualValues.Length, "ParametersAndViewChangedEvent_MatchDelete Params count");
+ ValidatePassedParams (expectedParams, actualValues,
"ParametersAndViewChangedEvent_MatchDelete expecte '{0}'");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_MatchOldDelete ()
+ {
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ SqlViewPoker view = InitializeView
(InitViewType.MatchParamsToOldValues, ConflictOptions.OverwriteChanges, out
keys, out old_values, out new_values);
+
+ view.Delete (keys, old_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("DeleteParameters_ParametersChanged",
eventsCalled [0], "DeleteParameters_ParametersChanged");
+ Assert.AreEqual ("view_Deleting", eventsCalled [1],
"view_Deleting");
+ string [] expectedParams = new string []
+ {
+
"String:@oldvalue_ID=k_1001",
+ };
+ string [] actualValues = ((string) eventsCalled
[2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+ Assert.AreEqual (expectedParams.Length,
actualValues.Length, "ParametersAndViewChangedEvent_MatchOldDelete Params
count");
+ ValidatePassedParams (expectedParams, actualValues,
"ParametersAndViewChangedEvent_MatchOldDelete expecte '{0}'");
+ }
+
+ [Test]
+ public void
ParametersAndViewChangedEvent_MatchOldDeleteAllValues ()
+ {
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ SqlViewPoker view = InitializeView
(InitViewType.MatchParamsToOldValues, ConflictOptions.CompareAllValues, out
keys, out old_values, out new_values);
+
+ view.Delete (keys, old_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("DeleteParameters_ParametersChanged",
eventsCalled [0], "DeleteParameters_ParametersChanged");
+ Assert.AreEqual ("view_Deleting", eventsCalled [1],
"view_Deleting");
+ string [] expectedParams = new string []
+ {
+
"String:@oldvalue_ID=ov_1001",
+ };
+ string [] actualValues = ((string) eventsCalled
[2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+ Assert.AreEqual (expectedParams.Length,
actualValues.Length, "ParametersAndViewChangedEvent_MatchOldDelete Params
count");
+ ValidatePassedParams (expectedParams, actualValues,
"ParametersAndViewChangedEvent_MatchOldDelete expecte '{0}'");
+ }
+
+ [Test]
+ public void ParametersAndViewChangedEvent_DontMatchDelete ()
+ {
+ Hashtable keys = null;
+ Hashtable old_values = null;
+ Hashtable new_values = null;
+ SqlViewPoker view = InitializeView
(InitViewType.DontMatchParams, ConflictOptions.OverwriteChanges, out keys, out
old_values, out new_values);
+
+ view.Delete (keys, old_values);
+
+ Assert.IsNotNull (eventsCalled, "Events not raized");
+ Assert.AreEqual (3, eventsCalled.Count, "Events Count");
+ Assert.AreEqual ("DeleteParameters_ParametersChanged",
eventsCalled [0], "DeleteParameters_ParametersChanged");
+ Assert.AreEqual ("view_Deleting", eventsCalled [1],
"view_Deleting");
+ string [] expectedParams = new string []
+ {
+
"String:@oldvalue_ID=k_1001",
+
"String:@OtherValue=p_OtherValueDelete1"
+ };
+ string [] actualValues = ((string) eventsCalled
[2]).Split (new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
+ Assert.AreEqual (expectedParams.Length,
actualValues.Length, "ParametersAndViewChangedEvent_MatchOldDelete Params
count");
+ ValidatePassedParams (expectedParams, actualValues,
"ParametersAndViewChangedEvent_MatchOldDelete expecte '{0}'");
+ }
+
+ private static void ValidatePassedParams (string []
expectedParams, string [] actualValues, string errorMessageFormat)
+ {
+ foreach (string eps in expectedParams) {
+ bool found = false;
+ foreach (string aps in actualValues) {
+ if (eps == aps) {
+ found = true;
+ break;
+ }
+ }
+ Assert.IsTrue (found, String.Format
(errorMessageFormat, eps));
+ }
+ }
}
}
_______________________________________________
Mono-patches maillist - [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches