/// <summary>
/// Initializes all service actions in the provider.
/// </summary>
/// <param name="operationContext">The operation context instance of the request.</param>
private void InitializeServiceActions(DataServiceOperationContext operationContext)
{
if (operationContext == null)
{
throw new DataServiceException("operationContext must not be null!");
}
var actionInfos = Interlocked.Exchange(ref this.serviceActionInfos, new Dictionary <string, DSPServiceActionInfo>());
if (actionInfos.Count > 0)
{
IDataServiceMetadataProvider metadataProvider = (IDataServiceMetadataProvider)operationContext.GetService(typeof(IDataServiceMetadataProvider));
if (metadataProvider == null)
{
throw new DataServiceException("DataServiceOperationContext.GetService(typeof(IDataServiceMetadataProvider)) must return a valid instance of the IDataServiceMetadataProvider.");
}
foreach (var entry in actionInfos)
{
DSPServiceActionInfo actionInfo = entry.Value;
DSPActionAttribute actionAttribute = actionInfo.ActionAttribute;
MethodInfo actionMethodInfo = actionInfo.Method;
ResourceType returnType = DSPActionProvider.GetResourceTypeFromType(metadataProvider, actionInfo.Method.ReturnType, actionAttribute.ReturnElementTypeName);
var parameters = DSPActionProvider.GetServiceActionParameters(metadataProvider, actionAttribute, actionMethodInfo);
ServiceAction action;
if (!string.IsNullOrEmpty(actionAttribute.ReturnSetPath))
{
if (actionAttribute.OperationParameterBindingKind != OperationParameterBindingKind.Always && actionAttribute.OperationParameterBindingKind != OperationParameterBindingKind.Sometimes)
{
throw new DataServiceException("DSPActionAttribute.IsBindable must be true when DSPActionAttribute.ReturnSetPath is not null.");
}
ResourceSetPathExpression pathExpression = new ResourceSetPathExpression(actionAttribute.ReturnSetPath);
action = new ServiceAction(actionMethodInfo.Name, returnType, OperationParameterBindingKind.Sometimes, parameters, pathExpression);
}
else
{
ResourceSet returnSet = null;
if (!string.IsNullOrEmpty(actionAttribute.ReturnSet))
{
metadataProvider.TryResolveResourceSet(actionAttribute.ReturnSet, out returnSet);
}
action = new ServiceAction(actionMethodInfo.Name, returnType, returnSet, actionAttribute.OperationParameterBindingKind, parameters);
}
action.CustomState = actionInfo;
action.SetReadOnly();
this.serviceActions.Add(actionMethodInfo.Name, action);
}
}
}
/// <summary>
/// Initializes a new <see cref="ServiceAction"/> instance.
/// </summary>
/// <param name="name">name of the action.</param>
/// <param name="returnType">Return type of the action.</param>
/// <param name="pathExpression">Path expression to calculate the result resource set of the function if the action returns an entity or a collection of entity; null otherwise.</param>
/// <param name="parameters">In-order parameters for this action.</param>
/// <param name="instance">The instance on which to invoke the operation.</param>
/// <param name="method">The methodInfo for the operation.</param>
public ServiceAction AddAction(string name, ResourceType returnType, ResourceSetPathExpression pathExpression, IEnumerable <ServiceActionParameter> parameters, object instance = null, MethodInfo method = null)
{
OperationParameterBindingKind kind = OperationParameterBindingKind.Sometimes;
if (instance != null)
{
Enum.TryParse(instance.ToString(), true, out kind);
}
ServiceAction action = new ServiceAction(name, returnType, kind, parameters, pathExpression);
return(this.AddServiceAction(action, method, instance));
}
public void PathExpressionTest()
{
var expression = new ResourceSetPathExpression("param1");
Assert.AreEqual("param1", expression.PathExpression, "Invalid value in PathExpression.");
expression = new ResourceSetPathExpression("param1/P1");
Assert.AreEqual("param1/P1", expression.PathExpression, "Invalid value in PathExpression.");
expression = new ResourceSetPathExpression("param1/P1/P2");
Assert.AreEqual("param1/P1/P2", expression.PathExpression, "Invalid value in PathExpression.");
expression = new ResourceSetPathExpression("param1/FQNS.T1/P1/FQNS.T2/P2");
Assert.AreEqual("param1/FQNS.T1/P1/FQNS.T2/P2", expression.PathExpression, "Invalid value in PathExpression.");
}
public void GetTargetSetTestsSetBindingTypeShouldPerformCorrectValidation()
{
ResourceType actorEntityType = new ResourceType(typeof(object), ResourceTypeKind.EntityType, null, "foo", "Actor", false)
{
CanReflectOnInstanceType = false
};
ResourceProperty idProperty = new ResourceProperty("ID", ResourcePropertyKind.Primitive | ResourcePropertyKind.Key, ResourceType.GetPrimitiveResourceType(typeof(int)))
{
CanReflectOnInstanceTypeProperty = false
};
actorEntityType.AddProperty(idProperty);
ResourceType addressComplexType = new ResourceType(typeof(object), ResourceTypeKind.ComplexType, null, "foo", "Address", false)
{
CanReflectOnInstanceType = false
};
addressComplexType.AddProperty(new ResourceProperty("StreetAddress", ResourcePropertyKind.Primitive, ResourceType.GetPrimitiveResourceType(typeof(string)))
{
CanReflectOnInstanceTypeProperty = false
});
addressComplexType.AddProperty(new ResourceProperty("ZipCode", ResourcePropertyKind.Primitive, ResourceType.GetPrimitiveResourceType(typeof(int)))
{
CanReflectOnInstanceTypeProperty = false
});
actorEntityType.AddProperty(new ResourceProperty("PrimaryAddress", ResourcePropertyKind.ComplexType, addressComplexType)
{
CanReflectOnInstanceTypeProperty = false
});
actorEntityType.AddProperty(new ResourceProperty("OtherAddresses", ResourcePropertyKind.Collection, ResourceType.GetCollectionResourceType(addressComplexType))
{
CanReflectOnInstanceTypeProperty = false
});
ResourceType movieEntityType = new ResourceType(typeof(object), ResourceTypeKind.EntityType, null, "foo", "Movie", false)
{
CanReflectOnInstanceType = false
};
movieEntityType.AddProperty(idProperty);
ResourceProperty moviesNavProp = new ResourceProperty("Movies", ResourcePropertyKind.ResourceSetReference, movieEntityType)
{
CanReflectOnInstanceTypeProperty = false
};
actorEntityType.AddProperty(moviesNavProp);
ResourceProperty actorsNavProp = new ResourceProperty("Actors", ResourcePropertyKind.ResourceSetReference, actorEntityType)
{
CanReflectOnInstanceTypeProperty = false
};
movieEntityType.AddProperty(actorsNavProp);
ResourceType derivedActorEntityType = new ResourceType(typeof(object), ResourceTypeKind.EntityType, actorEntityType, "foo", "DerivedActor", false)
{
CanReflectOnInstanceType = false
};
ResourceType derivedMovieEntityType = new ResourceType(typeof(object), ResourceTypeKind.EntityType, movieEntityType, "foo", "DerivedMovie", false)
{
CanReflectOnInstanceType = false
};
actorEntityType.SetReadOnly();
derivedActorEntityType.SetReadOnly();
movieEntityType.SetReadOnly();
derivedMovieEntityType.SetReadOnly();
addressComplexType.SetReadOnly();
DataServiceProviderSimulator providerSimulator = new DataServiceProviderSimulator();
providerSimulator.AddResourceType(actorEntityType);
providerSimulator.AddResourceType(derivedActorEntityType);
providerSimulator.AddResourceType(movieEntityType);
providerSimulator.AddResourceType(derivedMovieEntityType);
providerSimulator.AddResourceType(addressComplexType);
ResourceSet actorSet = new ResourceSet("Actors", actorEntityType);
ResourceSet movieSet = new ResourceSet("Movies", movieEntityType);
actorSet.SetReadOnly();
movieSet.SetReadOnly();
providerSimulator.AddResourceSet(actorSet);
providerSimulator.AddResourceSet(movieSet);
providerSimulator.AddResourceAssociationSet(new ResourceAssociationSet("Actors_Movies", new ResourceAssociationSetEnd(actorSet, actorEntityType, moviesNavProp), new ResourceAssociationSetEnd(movieSet, movieEntityType, actorsNavProp)));
DataServiceConfiguration config = new DataServiceConfiguration(providerSimulator);
config.SetEntitySetAccessRule("*", EntitySetRights.All);
config.DataServiceBehavior.MaxProtocolVersion = ODataProtocolVersion.V4;
var dataService = new DataServiceSimulator()
{
OperationContext = new DataServiceOperationContext(new DataServiceHostSimulator())
};
dataService.ProcessingPipeline = new DataServiceProcessingPipeline();
DataServiceStaticConfiguration staticConfiguration = new DataServiceStaticConfiguration(dataService.Instance.GetType(), providerSimulator);
IDataServiceProviderBehavior providerBehavior = DataServiceProviderBehavior.CustomDataServiceProviderBehavior;
DataServiceProviderWrapper provider = new DataServiceProviderWrapper(
new DataServiceCacheItem(
config,
staticConfiguration),
providerSimulator,
providerSimulator,
dataService,
false);
dataService.Provider = provider;
provider.ProviderBehavior = providerBehavior;
var testCases = new[]
{
new
{
AppendParameterName = true,
Path = "",
BindingSet = ResourceSetWrapper.CreateResourceSetWrapper(actorSet, provider, set => set),
TargetSet = ResourceSetWrapper.CreateResourceSetWrapper(actorSet, provider, set => set),
ErrorMessage = default(string)
},
new
{
AppendParameterName = true,
Path = "/Movies",
BindingSet = ResourceSetWrapper.CreateResourceSetWrapper(actorSet, provider, set => set),
TargetSet = ResourceSetWrapper.CreateResourceSetWrapper(movieSet, provider, set => set),
ErrorMessage = default(string)
},
new
{
AppendParameterName = true,
Path = "/Movies/Actors/Movies",
BindingSet = ResourceSetWrapper.CreateResourceSetWrapper(actorSet, provider, set => set),
TargetSet = ResourceSetWrapper.CreateResourceSetWrapper(movieSet, provider, set => set),
ErrorMessage = default(string)
},
new
{
AppendParameterName = true,
Path = "/foo.DerivedActor/Movies/foo.DerivedMovie/Actors/foo.DerivedActor/Movies",
BindingSet = ResourceSetWrapper.CreateResourceSetWrapper(actorSet, provider, set => set),
TargetSet = ResourceSetWrapper.CreateResourceSetWrapper(movieSet, provider, set => set),
ErrorMessage = default(string)
},
new
{
AppendParameterName = true,
Path = "/",
BindingSet = ResourceSetWrapper.CreateResourceSetWrapper(actorSet, provider, set => set),
TargetSet = default(ResourceSetWrapper),
ErrorMessage = "The path expression '{0}/' is not a valid expression because it contains an empty segment or it ends with '/'."
},
new
{
AppendParameterName = true,
Path = "/Movies/",
BindingSet = ResourceSetWrapper.CreateResourceSetWrapper(actorSet, provider, set => set),
TargetSet = default(ResourceSetWrapper),
ErrorMessage = "The path expression '{0}/Movies/' is not a valid expression because it contains an empty segment or it ends with '/'."
},
new
{
AppendParameterName = true,
Path = "/Movies//Actors",
BindingSet = ResourceSetWrapper.CreateResourceSetWrapper(actorSet, provider, set => set),
TargetSet = ResourceSetWrapper.CreateResourceSetWrapper(movieSet, provider, set => set),
ErrorMessage = "The path expression '{0}/Movies//Actors' is not a valid expression because it contains an empty segment or it ends with '/'."
},
new
{
AppendParameterName = true,
Path = "/foo.DerivedActor",
BindingSet = ResourceSetWrapper.CreateResourceSetWrapper(actorSet, provider, set => set),
TargetSet = default(ResourceSetWrapper),
ErrorMessage = "The path expression '{0}/foo.DerivedActor' is not a valid expression because it ends with the type identifier 'foo.DerivedActor'. A valid path expression must not end in a type identifier."
},
new
{
AppendParameterName = true,
Path = "/Movies/foo.DerivedMovie",
BindingSet = ResourceSetWrapper.CreateResourceSetWrapper(actorSet, provider, set => set),
TargetSet = default(ResourceSetWrapper),
ErrorMessage = "The path expression '{0}/Movies/foo.DerivedMovie' is not a valid expression because it ends with the type identifier 'foo.DerivedMovie'. A valid path expression must not end in a type identifier."
},
new
{
AppendParameterName = true,
Path = "/Foo",
BindingSet = ResourceSetWrapper.CreateResourceSetWrapper(actorSet, provider, set => set),
TargetSet = default(ResourceSetWrapper),
ErrorMessage = "The path expression '{0}/Foo' is not a valid expression because the segment 'Foo' is not a type identifier or a property on the resource type 'foo.Actor'."
},
new
{
AppendParameterName = true,
Path = "/ID",
BindingSet = ResourceSetWrapper.CreateResourceSetWrapper(actorSet, provider, set => set),
TargetSet = default(ResourceSetWrapper),
ErrorMessage = "The path expression '{0}/ID' is not a valid expression because the segment 'ID' is a property of type 'Edm.Int32'. A valid path expression must only contain properties of entity type."
},
new
{
AppendParameterName = true,
Path = "/OtherAddresses",
BindingSet = ResourceSetWrapper.CreateResourceSetWrapper(actorSet, provider, set => set),
TargetSet = default(ResourceSetWrapper),
ErrorMessage = "The path expression '{0}/OtherAddresses' is not a valid expression because the segment 'OtherAddresses' is a property of type 'Collection(foo.Address)'. A valid path expression must only contain properties of entity type."
},
new
{
AppendParameterName = true,
Path = "/Movies/Actors/PrimaryAddress",
BindingSet = ResourceSetWrapper.CreateResourceSetWrapper(actorSet, provider, set => set),
TargetSet = default(ResourceSetWrapper),
ErrorMessage = "The path expression '{0}/Movies/Actors/PrimaryAddress' is not a valid expression because the segment 'PrimaryAddress' is a property of type 'foo.Address'. A valid path expression must only contain properties of entity type."
},
new
{
AppendParameterName = false,
Path = "foo",
BindingSet = ResourceSetWrapper.CreateResourceSetWrapper(actorSet, provider, set => set),
TargetSet = default(ResourceSetWrapper),
ErrorMessage = "The path expression 'foo' is not a valid path expression. A valid path expression must start with the binding parameter name '{0}'."
},
new
{
AppendParameterName = false,
Path = "abc/pqr",
BindingSet = ResourceSetWrapper.CreateResourceSetWrapper(actorSet, provider, set => set),
TargetSet = default(ResourceSetWrapper),
ErrorMessage = "The path expression 'abc/pqr' is not a valid path expression. A valid path expression must start with the binding parameter name '{0}'."
},
new
{
AppendParameterName = false,
Path = "actorParameter",
BindingSet = ResourceSetWrapper.CreateResourceSetWrapper(actorSet, provider, set => set),
TargetSet = default(ResourceSetWrapper),
ErrorMessage = "The path expression 'actorParameter' is not a valid path expression. A valid path expression must start with the binding parameter name '{0}'."
},
new
{
AppendParameterName = false,
Path = "actorsParameter",
BindingSet = ResourceSetWrapper.CreateResourceSetWrapper(actorSet, provider, set => set),
TargetSet = default(ResourceSetWrapper),
ErrorMessage = "The path expression 'actorsParameter' is not a valid path expression. A valid path expression must start with the binding parameter name '{0}'."
},
};
ServiceActionParameter actorParameter = new ServiceActionParameter("actor", actorEntityType);
ServiceActionParameter actorsParameter = new ServiceActionParameter("actors", ResourceType.GetEntityCollectionResourceType(actorEntityType));
var parameters = new ServiceActionParameter[] { actorParameter, actorsParameter };
foreach (var parameter in parameters)
{
foreach (var testCase in testCases)
{
string pathString = testCase.AppendParameterName ? parameter.Name + testCase.Path : testCase.Path;
var path = new ResourceSetPathExpression(pathString);
Assert.AreEqual(pathString, path.PathExpression);
string expectedErrorMessage = testCase.ErrorMessage == null ? null : string.Format(testCase.ErrorMessage, parameter.Name);
try
{
path.SetBindingParameter(parameter);
path.InitializePathSegments(provider);
var targetSet = path.GetTargetSet(provider, testCase.BindingSet);
Assert.IsNull(expectedErrorMessage, "Expecting exception but received none.");
Assert.AreEqual(targetSet.Name, testCase.TargetSet.Name);
}
catch (InvalidOperationException e)
{
Assert.AreEqual(expectedErrorMessage, e.Message);
}
}
}
}
public void ServiceActionConstructorTests()
{
ResourceProperty id = new ResourceProperty("ID", ResourcePropertyKind.Primitive | ResourcePropertyKind.Key, ResourceType.GetPrimitiveResourceType(typeof(int)));
ResourceType customerType = new ResourceType(typeof(object), ResourceTypeKind.EntityType, null, "Foo", "Customer", false);
customerType.AddProperty(id);
customerType.SetReadOnly();
ResourceSet customerSet = new ResourceSet("Customers", customerType);
ResourceType orderType = new ResourceType(typeof(object), ResourceTypeKind.EntityType, null, "Foo", "Order", false);
orderType.AddProperty(id);
orderType.SetReadOnly();
ResourceType complexType = new ResourceType(typeof(object), ResourceTypeKind.ComplexType, null, "foo", "Address", false);
ResourceType collectionOfPrimitive = ResourceType.GetCollectionResourceType(ResourceType.GetPrimitiveResourceType(typeof(int)));
ResourceType collectionOfComplex = ResourceType.GetCollectionResourceType(complexType);
ResourceType collectionOfCustomer = ResourceType.GetEntityCollectionResourceType(customerType);
ResourceType collectionOfOrder = ResourceType.GetEntityCollectionResourceType(orderType);
var types = ResourceTypeUtils.GetPrimitiveResourceTypes().Concat(new ResourceType[] { null, customerType, orderType, complexType, collectionOfPrimitive, collectionOfComplex, collectionOfCustomer, collectionOfOrder });
var resultSetsOrPathExpressions = new object[] { null, customerSet, new ResourceSetPathExpression("p1/Foo") };
var parameters = types.Except(new[] { ResourceType.GetPrimitiveResourceType(typeof(System.IO.Stream)) }).Select(t => t != null ? new ServiceActionParameter[] { new ServiceActionParameter("p1", t) } : new ServiceActionParameter[0]);
parameters = parameters.Concat(types.Except(new[] { ResourceType.GetPrimitiveResourceType(typeof(System.IO.Stream)), null }).ToList().Combinations(2).Select(tt => new ServiceActionParameter[] { new ServiceActionParameter("p1", tt[0]), new ServiceActionParameter("p2", tt[1]) }));
var operationParameterBindings = new OperationParameterBindingKind[] { OperationParameterBindingKind.Never, OperationParameterBindingKind.Sometimes, OperationParameterBindingKind.Always };
AstoriaTestNS.TestUtil.RunCombinations(
types, resultSetsOrPathExpressions, parameters, operationParameterBindings,
(returnType, resultSetOrPathExpression, paramList, operationParameterBindingKind) =>
{
ServiceAction action = null;
ResourceSet resourceSet = resultSetOrPathExpression as ResourceSet;
ResourceSetPathExpression pathExpression = resultSetOrPathExpression as ResourceSetPathExpression;
bool bindable = (operationParameterBindingKind == OperationParameterBindingKind.Always || operationParameterBindingKind == OperationParameterBindingKind.Sometimes);
Exception e = null;
try
{
if (pathExpression != null)
{
bindable = true;
action = new ServiceAction("foo", returnType, OperationParameterBindingKind.Sometimes, paramList, pathExpression);
}
else
{
action = new ServiceAction("foo", returnType, resourceSet, operationParameterBindingKind, paramList);
}
}
catch (Exception ex)
{
e = ex;
}
if (resourceSet != null && operationParameterBindingKind != OperationParameterBindingKind.Never)
{
ExceptionUtils.IsExpectedException <ArgumentException>(e, "When 'returnType' is an entity type or an entity collection type, 'resultSetPathExpression' and 'resultSet' cannot be both null and the resource type of the result set must be assignable from 'returnType'.");
}
else if (returnType != null && (returnType.ResourceTypeKind == ResourceTypeKind.EntityType || returnType.ResourceTypeKind == ResourceTypeKind.EntityCollection) &&
(resourceSet == null && pathExpression == null ||
resourceSet != null && returnType.ResourceTypeKind == ResourceTypeKind.EntityType && resourceSet.ResourceType != returnType ||
resourceSet != null && returnType.ResourceTypeKind == ResourceTypeKind.EntityCollection && resourceSet.ResourceType != ((EntityCollectionResourceType)returnType).ItemType))
{
ExceptionUtils.IsExpectedException <ArgumentException>(e, "When 'returnType' is an entity type or an entity collection type, 'resultSetPathExpression' and 'resultSet' cannot be both null and the resource type of the result set must be assignable from 'returnType'.");
}
else if ((returnType == null || returnType.ResourceTypeKind != ResourceTypeKind.EntityCollection && returnType.ResourceTypeKind != ResourceTypeKind.EntityType) && resourceSet != null)
{
ExceptionUtils.IsExpectedException <ArgumentException>(e, "'resultSet' must be null when 'returnType' is null, not an entity type or not an entity collection type.");
}
else if ((returnType == null || returnType.ResourceTypeKind != ResourceTypeKind.EntityCollection && returnType.ResourceTypeKind != ResourceTypeKind.EntityType) && pathExpression != null)
{
ExceptionUtils.IsExpectedException <ArgumentException>(e, "'resultSetPathExpression' must be null when 'returnType' is null, not an entity type or not an entity collection type.");
}
else if (returnType == ResourceType.GetPrimitiveResourceType(typeof(System.IO.Stream)))
{
ExceptionUtils.IsExpectedException <ArgumentException>(e, "The resource type 'Edm.Stream' is not a type that can be returned by a function or action. A function or action can only return values of an entity type, an entity collection type, a complex type, a collection type or any primitive type, other than the stream type.\r\nParameter name: returnType");
}
else if (paramList.Length > 0 && paramList.Skip(bindable ? 1 : 0).Any(p => p.ParameterType.ResourceTypeKind == ResourceTypeKind.EntityType || p.ParameterType.ResourceTypeKind == ResourceTypeKind.EntityCollection))
{
var param = paramList.Skip(bindable ? 1 : 0).First(p => p.ParameterType.ResourceTypeKind == ResourceTypeKind.EntityType || p.ParameterType.ResourceTypeKind == ResourceTypeKind.EntityCollection);
var parameterTypeKind = param.ParameterType.ResourceTypeKind;
ExceptionUtils.IsExpectedException <ArgumentException>(e, string.Format("The '{0}' parameter is of resource type kind '{1}' and it is not the binding parameter. Parameter of type kind '{1}' is only supported for the binding parameter.", param.Name, parameterTypeKind));
}
else if (pathExpression != null && !bindable)
{
ExceptionUtils.IsExpectedException <ArgumentException>(e, "The binding parameter type must be an entity type or an entity collection type when 'resultSetPathExpression' is not null.");
}
else if (bindable && paramList.Length == 0)
{
ExceptionUtils.IsExpectedException <ArgumentException>(e, "Bindable actions or functions must have at least one parameter, where the first parameter is the binding parameter.\r\nParameter name: operationParameterBindingKind");
}
else if (pathExpression != null && bindable && paramList.First().ParameterType.ResourceTypeKind != ResourceTypeKind.EntityType && paramList.First().ParameterType.ResourceTypeKind != ResourceTypeKind.EntityCollection)
{
ExceptionUtils.IsExpectedException <ArgumentException>(e, "The binding parameter type must be an entity type or an entity collection type when 'resultSetPathExpression' is not null.");
}
else if (paramList.Length > 0 && bindable && paramList[0].ParameterType.ResourceTypeKind != ResourceTypeKind.EntityType && paramList[0].ParameterType.ResourceTypeKind != ResourceTypeKind.EntityCollection)
{
ExceptionUtils.IsExpectedException <ArgumentException>(e, "An action's binding parameter must be of type Entity or EntityCollection.\r\nParameter name: parameters");
}
else
{
Assert.IsNull(e, "Received exception but expected none. Exception message: {0}", e == null ? string.Empty : e.Message);
Assert.IsNotNull(action, "Action should be constructed.");
Assert.AreEqual("foo", action.Name, "unexpected name");
Assert.AreEqual(returnType, action.ReturnType, "unexpected return type");
Assert.AreEqual(resourceSet, action.ResourceSet, "unexpected result set");
Assert.AreEqual(pathExpression, action.ResultSetPathExpression, "unexpected path expression");
Assert.IsTrue(!bindable || action.BindingParameter == action.Parameters.First(), "unexpected binding parameter");
Assert.IsTrue(action.Method == "POST", "HttpMethod must be POST for ServiceActions.");
Assert.IsTrue(action.ResourceSet == null || action.ResultSetPathExpression == null, "'resultSet' and 'resultSetPathExpression' cannot be both set by the constructor.");
}
});
}
