public void ServiceOperationTypes()
{
ResourceType complexType = new ResourceType(typeof(object), ResourceTypeKind.ComplexType, null, "foo", "Address", false);
ResourceType entityType = new ResourceType(typeof(object), ResourceTypeKind.EntityType, null, "foo", "Order", false);
ResourceSet entitySet = new ResourceSet("Set", entityType);
ResourceType collectionOfPrimitive = ResourceType.GetCollectionResourceType(ResourceType.GetPrimitiveResourceType(typeof(int)));
ResourceType collectionOfComplex = ResourceType.GetCollectionResourceType(complexType);
var returnTypeDirectCases = ResourceTypeUtils.GetPrimitiveResourceTypes().Select(rt => new { Type = rt, Set = (ResourceSet)null, Invalid = rt.InstanceType == typeof(System.IO.Stream) ? true : false })
.Concat(new[] {
new { Type = complexType, Set = (ResourceSet)null, Invalid = false },
new { Type = entityType, Set = entitySet, Invalid = false }
})
.Concat(new ResourceType[] { collectionOfPrimitive, collectionOfComplex }.Select(rt => new { Type = rt, Set = (ResourceSet)null, Invalid = true }));
AstoriaTestNS.TestUtil.RunCombinations(returnTypeDirectCases, (returnTypeDirectCase) =>
{
Exception e = AstoriaTestNS.TestUtil.RunCatching(() =>
new ServiceOperation("so", ServiceOperationResultKind.DirectValue, returnTypeDirectCase.Type, returnTypeDirectCase.Set, "GET", null));
if (returnTypeDirectCase.Invalid)
{
Assert.IsNotNull(e, "Service op should have failed to be constructed.");
Assert.IsTrue(e is ArgumentException, "Invalid exception type.");
}
else
{
Assert.IsNull(e, "Service op should have succeeded.");
}
});
}
public void ServiceActionParameterInvalidCasesTest()
{
ResourceType complexType = new ResourceType(typeof(object), ResourceTypeKind.ComplexType, null, "foo", "Address", false);
ResourceType entityType = new ResourceType(typeof(object), ResourceTypeKind.EntityType, null, "foo", "Order", false);
ResourceSet entitySet = new ResourceSet("Set", entityType);
ResourceType collectionOfPrimitive = ResourceType.GetCollectionResourceType(ResourceType.GetPrimitiveResourceType(typeof(int)));
ResourceType collectionOfComplex = ResourceType.GetCollectionResourceType(complexType);
ResourceType collectionType = ResourceType.GetEntityCollectionResourceType(entityType);
var parameterTypes = ResourceTypeUtils.GetPrimitiveResourceTypes()
.Concat(new ResourceType[] {
complexType,
entityType,
collectionOfPrimitive,
collectionOfComplex,
collectionType
});
AstoriaTestNS.TestUtil.RunCombinations(parameterTypes, (parameterType) =>
{
Exception e = AstoriaTestNS.TestUtil.RunCatching(() => new ServiceActionParameter("p", parameterType));
if (parameterType != ResourceType.GetPrimitiveResourceType(typeof(System.IO.Stream)))
{
Assert.IsNull(e, "Service op parameter should have succeeded.");
}
else
{
ExceptionUtils.IsExpectedException <ArgumentException>(e, "The service operation parameter 'p' of type 'Edm.Stream' is not supported.\r\nParameter name: parameterType");
}
});
}
public void CollectionTypeValidation()
{
ResourceType entityType = new ResourceType(typeof(object), ResourceTypeKind.EntityType, null, "foo", "Order", false);
ResourceType complexType = new ResourceType(typeof(object), ResourceTypeKind.ComplexType, null, "foo", "bar", false);
ResourceType complexType2 = new ResourceType(typeof(object), ResourceTypeKind.ComplexType, null, "foo", "bar2", false);
complexType2.AddProperty(new ResourceProperty("CollectionProperty", ResourcePropertyKind.Collection, ResourceType.GetCollectionResourceType(complexType)));
var itemTypes = new ResourceType[] { complexType, complexType2 }.Concat(ResourceTypeUtils.GetPrimitiveResourceTypes());
var collectionTypes = itemTypes.Except(new[] { ResourceType.GetPrimitiveResourceType(typeof(System.IO.Stream)) }).Select(it => new { ItemType = it, CollectionType = ResourceType.GetCollectionResourceType(it) });
AstoriaTestNS.TestUtil.RunCombinations(
collectionTypes,
c =>
{
Assert.AreEqual(c.ItemType, c.CollectionType.ItemType, "The item type of the collection doesn't match the one specified upon creation.");
Assert.AreEqual("Collection(" + c.ItemType.FullName + ")", c.CollectionType.FullName, "The full name of a collection type is wrong.");
Assert.AreEqual("Collection(" + c.ItemType.FullName + ")", c.CollectionType.Name, "The name of a collection type is wrong.");
Assert.AreEqual("", c.CollectionType.Namespace, "The namespace of a collection type should be empty.");
Assert.IsTrue(c.CollectionType.IsReadOnly, "The collection type is always read-only.");
Assert.IsFalse(c.CollectionType.IsAbstract, "Collection type is never abstract.");
Assert.IsFalse(c.CollectionType.IsOpenType, "Collection type is never open.");
Assert.IsFalse(c.CollectionType.IsMediaLinkEntry, "Collection type is never an MLE.");
Assert.AreEqual(typeof(IEnumerable <>).MakeGenericType(c.ItemType.InstanceType), c.CollectionType.InstanceType, "The instance type of the collection type is wrong.");
Assert.IsTrue(c.CollectionType.CanReflectOnInstanceType, "Collection type has CanReflectOnInstanceType always true.");
Assert.IsNull(c.CollectionType.BaseType, "Collection type has never a base type.");
Assert.AreEqual(ResourceTypeKind.Collection, c.CollectionType.ResourceTypeKind, "The kind of a collection type is always Collection.");
Assert.AreEqual(0, c.CollectionType.PropertiesDeclaredOnThisType.Count(), "Collection type has no properties.");
Assert.AreEqual(0, c.CollectionType.Properties.Count(), "Collection type has no properties.");
Assert.AreEqual(0, c.CollectionType.KeyProperties.Count(), "Collection type has no properties.");
Assert.AreEqual(0, c.CollectionType.ETagProperties.Count(), "Collection type has no properties.");
Assert.IsNull(c.CollectionType.CustomState, "Custom state should be null by default.");
ExceptionUtils.ThrowsException <InvalidOperationException>(
() => c.CollectionType.IsMediaLinkEntry = true,
"Setting MLE on collection type should fail.");
ExceptionUtils.ThrowsException <InvalidOperationException>(
() => c.CollectionType.IsOpenType = true,
"Setting IsOpenType on collection type should fail.");
ExceptionUtils.ThrowsException <InvalidOperationException>(
() => c.CollectionType.CanReflectOnInstanceType = false,
"Setting CanReflectOnInstanceType on collection type should fail.");
// Setting a custom state should still work
c.CollectionType.CustomState = "some value";
Assert.AreEqual("some value", c.CollectionType.CustomState, "Custom state doesn't persist its value.");
ExceptionUtils.ThrowsException <InvalidOperationException>(
() => c.CollectionType.AddProperty(new ResourceProperty("ID", ResourcePropertyKind.ComplexType, complexType)),
"Adding a property on collection type should fail.");
c.CollectionType.SetReadOnly();
Assert.IsTrue(c.CollectionType.IsReadOnly, "The collection type is always read-only.");
});
// Verify that only primitive and complex types are allowed as items in a collection
ResourceType collectionType = ResourceType.GetCollectionResourceType(complexType);
foreach (var t in new ResourceType[] { entityType, collectionType })
{
Exception exception = AstoriaTestNS.TestUtil.RunCatching(() => ResourceType.GetCollectionResourceType(t));
Assert.IsTrue(exception is ArgumentException, "Exception of a wrong type");
Assert.AreEqual(
"Only collection properties that contain primitive types or complex types are supported.",
exception.Message, "Wrong exception message.");
}
}
public void InvalidCasesTest()
{
ResourceType rt = (ResourceType)ResourceTypeUtils.GetTestInstance(typeof(ResourceType));
ResourceType complexType = new ResourceType(typeof(object), ResourceTypeKind.ComplexType, null, "Namespace", "Address", false);
ResourceType entityType = new ResourceType(typeof(object), ResourceTypeKind.EntityType, null, "Namespace", "Order", false);
ResourceType primitiveOrComplexCollectionType = ResourceType.GetCollectionResourceType(complexType);
ResourceType entityCollectionType = ResourceType.GetEntityCollectionResourceType(entityType);
ResourceType namedStreamType = ResourceType.GetPrimitiveResourceType(typeof(System.IO.Stream));
AstoriaTestNS.TestUtil.RunCombinations(
GetPropertyKindValues(),
new ResourceType[] { entityType, complexType, primitiveOrComplexCollectionType, entityCollectionType }.Concat(ResourceTypeUtils.GetPrimitiveResourceTypes()),
(kind, type) =>
{
bool invalidCase = true;
if (IsValidValue(kind))
{
if ((kind.HasFlag(ResourcePropertyKind.Primitive) && type.ResourceTypeKind == ResourceTypeKind.Primitive && type != namedStreamType) ||
(kind.HasFlag(ResourcePropertyKind.ComplexType) && type.ResourceTypeKind == ResourceTypeKind.ComplexType) ||
(kind.HasFlag(ResourcePropertyKind.ResourceReference) && type.ResourceTypeKind == ResourceTypeKind.EntityType) ||
(kind.HasFlag(ResourcePropertyKind.ResourceSetReference) && type.ResourceTypeKind == ResourceTypeKind.EntityType) ||
(kind.HasFlag(ResourcePropertyKind.Collection) && type.ResourceTypeKind == ResourceTypeKind.Collection) ||
(kind.HasFlag(ResourcePropertyKind.Stream) && type == namedStreamType))
{
invalidCase = false;
}
if ((kind & ResourcePropertyKind.Key) == ResourcePropertyKind.Key &&
type.InstanceType.IsGenericType && type.InstanceType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
invalidCase = true;
}
}
if (invalidCase)
{
ExceptionUtils.ThrowsException <ArgumentException>(
() => new ResourceProperty("TestProperty", kind, type),
string.Format("resource property constructor test case. Kind: '{0}', Type: '{1}: {2}'", kind, type.ResourceTypeKind, type.InstanceType));
}
else
{
ResourceProperty p = new ResourceProperty("TestProperty", kind, type);
Assert.AreEqual("TestProperty", p.Name, "Name was not stored properly");
Assert.AreEqual(kind, p.Kind, "Kind was not stored properly");
Assert.AreEqual(type, p.ResourceType, "Type was not stored properly");
Assert.AreEqual(p.Kind.HasFlag(ResourcePropertyKind.Stream) ? false : true, p.CanReflectOnInstanceTypeProperty, "CanReflectOnInstanceTypeProperty should be true by default on non-NamedStreams, and false on NamedStreams.");
Assert.IsNull(p.MimeType, "MimeType should be null by default.");
if (p.Kind.HasFlag(ResourcePropertyKind.Stream))
{
ExceptionUtils.ThrowsException <InvalidOperationException>(
() => { p.CanReflectOnInstanceTypeProperty = false; },
"CanReflectOnInstanceTypeProperty should be settable on non-namedstreams, and not settable on namedstreams");
}
else
{
p.CanReflectOnInstanceTypeProperty = false;
}
Assert.AreEqual(false, p.CanReflectOnInstanceTypeProperty, "CanReflectOnInstanceTypeProperty should be false.");
bool shouldFail = true;
if ((kind & ResourcePropertyKind.Primitive) == ResourcePropertyKind.Primitive)
{
shouldFail = false;
}
if (shouldFail)
{
ExceptionUtils.ThrowsException <InvalidOperationException>(
() => p.MimeType = "plain/text",
string.Format("Setting MimeType on non-primitive property should fail. Kind: '{0}', Type: '{1}: {2}'", kind, type.ResourceTypeKind, type.InstanceType));
}
else
{
p.MimeType = "plain/text";
}
}
});
}
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.");
}
});
}
