public void CanCreateEdmModel_WithBindableFunction()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration <Customer> customer = builder.EntityType <Customer>();
customer.HasKey(c => c.CustomerId);
customer.Property(c => c.Name);
// Act
FunctionConfiguration sendEmail = customer.Function("FunctionName");
sendEmail.Returns <bool>();
IEdmModel model = builder.GetEdmModel();
// Assert
Assert.Equal(1, model.SchemaElements.OfType <IEdmFunction>().Count());
IEdmFunction function = Assert.Single(model.SchemaElements.OfType <IEdmFunction>());
Assert.False(function.IsComposable);
Assert.True(function.IsBound);
Assert.Equal("FunctionName", function.Name);
Assert.NotNull(function.ReturnType);
Assert.Equal(1, function.Parameters.Count());
Assert.Equal(BindingParameterConfiguration.DefaultBindingParameterName, function.Parameters.Single().Name);
Assert.Equal(typeof(Customer).FullName, function.Parameters.Single().Type.FullName());
}
public void Can_SetFunctionTitle_OnBindable_Functions()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
EntitySetConfiguration <Movie> movies = builder.EntitySet <Movie>("Movies");
movies.EntityType.HasKey(m => m.ID);
FunctionConfiguration entityAction = movies.EntityType.Function("Checkout");
entityAction.Returns <int>();
entityAction.Title = "Check out";
FunctionConfiguration collectionAction = movies.EntityType.Collection.Function("RemoveOld");
collectionAction.Returns <int>();
collectionAction.Title = "Remove Old Movies";
// Act
IEdmModel model = builder.GetEdmModel();
IEdmOperation checkout = model.FindOperations("Default.Checkout").Single();
IEdmOperation removeOld = model.FindOperations("Default.RemoveOld").Single();
OperationTitleAnnotation checkoutTitle = model.GetOperationTitleAnnotation(checkout);
OperationTitleAnnotation removeOldTitle = model.GetOperationTitleAnnotation(removeOld);
// Assert
Assert.NotNull(checkoutTitle);
Assert.Equal("Check out", checkoutTitle.Title);
Assert.NotNull(removeOldTitle);
Assert.Equal("Remove Old Movies", removeOldTitle.Title);
}
public void CanManuallyConfigureFunctionLinkFactory()
{
// Arrange
string uriTemplate = "http://server/service/Customers({0})/Reward";
Uri expectedUri = new Uri(string.Format(uriTemplate, 1));
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration <Customer> customer = builder.EntitySet <Customer>("Customers").EntityType;
customer.HasKey(c => c.CustomerId);
customer.Property(c => c.Name);
// Act
FunctionConfiguration reward = customer.Function("Reward");
reward.HasFunctionLink(ctx => new Uri(string.Format(uriTemplate, ctx.GetPropertyValue("CustomerId"))),
followsConventions: false);
reward.Returns <bool>();
IEdmModel model = builder.GetEdmModel();
IEdmEntityType customerType = model.SchemaElements.OfType <IEdmEntityType>().SingleOrDefault();
ODataSerializerContext serializerContext = new ODataSerializerContext {
Model = model
};
EntityInstanceContext context = new EntityInstanceContext(serializerContext, customerType.AsReference(), new Customer {
CustomerId = 1
});
IEdmFunction rewardFunction = Assert.Single(model.SchemaElements.OfType <IEdmFunction>()); // Guard
FunctionLinkBuilder functionLinkBuilder = model.GetAnnotationValue <FunctionLinkBuilder>(rewardFunction);
//Assert
Assert.Equal(expectedUri, reward.GetFunctionLink()(context));
Assert.NotNull(functionLinkBuilder);
Assert.Equal(expectedUri, functionLinkBuilder.BuildFunctionLink(context));
}
public void FunctionLink_PreservesFollowsConventions(bool value)
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
FunctionConfiguration configuration = new FunctionConfiguration(builder, "IgnoreFunction");
configuration.Returns <int>();
Mock <IEdmTypeConfiguration> bindingParameterTypeMock = new Mock <IEdmTypeConfiguration>();
bindingParameterTypeMock.Setup(o => o.Kind).Returns(EdmTypeKind.Entity);
Type entityType = typeof(object);
bindingParameterTypeMock.Setup(o => o.ClrType).Returns(entityType);
configuration.SetBindingParameter("IgnoreParameter", bindingParameterTypeMock.Object);
configuration.HasFunctionLink((a) => { throw new NotImplementedException(); }, followsConventions: value);
builder.AddOperation(configuration);
builder.AddEntityType(entityType);
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
var function = Assert.Single(model.SchemaElements.OfType <IEdmFunction>());
OperationLinkBuilder functionLinkBuilder = model.GetOperationLinkBuilder(function);
Assert.NotNull(functionLinkBuilder);
Assert.Equal(value, functionLinkBuilder.FollowsConventions);
}
public void CanCreateFunctionWithPrimitiveReturnType()
{
// Arrange
// Act
ODataModelBuilder builder = new ODataModelBuilder();
FunctionConfiguration function = builder.Function("CreateMessage");
function.Returns <string>();
// Assert
Assert.NotNull(function.ReturnType);
Assert.Equal("Edm.String", function.ReturnType.FullName);
}
public void Cant_SetFunctionTitle_OnNonBindableFunctions()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
FunctionConfiguration function = builder.Function("MyFunction");
function.Returns <int>();
function.Title = "My Function";
// Act
IEdmModel model = builder.GetEdmModel();
IEdmOperationImport functionImport = model.EntityContainer.OperationImports().OfType <IEdmFunctionImport>().Single();
Assert.NotNull(functionImport);
OperationTitleAnnotation functionTitleAnnotation = model.GetOperationTitleAnnotation(functionImport.Operation);
// Assert
Assert.Null(functionTitleAnnotation);
}
public void CanCreateEdmModel_WithTransientBindableFunction()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration <Customer> customer = builder.EntityType <Customer>();
customer.HasKey(c => c.CustomerId);
customer.Property(c => c.Name);
// Act
FunctionConfiguration sendEmail = customer.TransientFunction("FunctionName");
sendEmail.Returns <bool>();
IEdmModel model = builder.GetEdmModel();
// Assert
Assert.Equal(1, model.SchemaElements.OfType <IEdmFunction>().Count());
IEdmFunction function = Assert.Single(model.SchemaElements.OfType <IEdmFunction>());
Assert.True(function.IsBound);
}
public void BoundFunction_ForEnumTypeInODataModelBuilder()
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>().Add_Color_EnumType();
EntityTypeConfiguration <EnumModel> entityTypeConfiguration = builder.EntityType <EnumModel>();
FunctionConfiguration functionConfiguration = entityTypeConfiguration.Function("BoundFunction");
functionConfiguration.Parameter <Color?>("Color");
functionConfiguration.Returns <Color>();
// Act & Assert
IEdmModel model = builder.GetEdmModel();
IEdmFunction function = model.FindDeclaredOperations("Default.BoundFunction").Single() as IEdmFunction;
IEdmTypeReference color = function.Parameters.Single(p => p.Name == "Color").Type;
IEdmTypeReference returnType = function.ReturnType;
IEdmEnumType colorType = model.SchemaElements.OfType <IEdmEnumType>().Single(e => e.Name == "Color");
Assert.True(color.IsNullable);
Assert.Same(colorType, color.Definition);
Assert.Same(colorType, returnType.Definition);
}
public void BoundFunction_ForEnumWithLongUnderlyingTypeInODataModelBuilder()
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
builder.Add_LongEnum_EnumType();
EntityTypeConfiguration <EnumModel> entityTypeConfiguration = builder.EntityType <EnumModel>();
FunctionConfiguration functionConfiguration = entityTypeConfiguration.Function("BoundFunction");
functionConfiguration.Parameter <LongEnum>("LongEnum");
functionConfiguration.Returns <int>();
// Act & Assert
IEdmModel model = builder.GetEdmModel();
IEdmFunction function = model.FindDeclaredOperations("Default.BoundFunction").Single() as IEdmFunction;
IEdmTypeReference longEnumParameter = function.Parameters.Single(p => p.Name == "LongEnum").Type;
IEdmEnumType longEnumType = model.SchemaElements.OfType <IEdmEnumType>().Single(e => e.Name == "LongEnum");
Assert.Same(longEnumType, longEnumParameter.Definition);
Assert.Equal(EdmPrimitiveTypeKind.Int64, longEnumParameter.AsEnum().EnumDefinition().UnderlyingType.PrimitiveKind);
}
public void CanCreateEdmModel_ForBindableFunction_WithSupportedParameterType()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration <Customer> customer = builder.EntityType <Customer>();
customer.HasKey(c => c.CustomerId);
customer.Property(c => c.Name);
// Act
FunctionConfiguration functionBuilder = customer.Function("FunctionName");
functionBuilder.Parameter <int>("primitive");
functionBuilder.CollectionParameter <int>("collectionPrimitive");
functionBuilder.Parameter <bool?>("nullablePrimitive");
functionBuilder.CollectionParameter <bool?>("nullableCollectionPrimitive");
functionBuilder.Parameter <Color>("enum");
functionBuilder.CollectionParameter <Color>("collectionEnum");
functionBuilder.Parameter <Color?>("nullableEnum");
functionBuilder.CollectionParameter <Color?>("nullableCollectionEnum");
functionBuilder.Parameter <Address>("complex");
functionBuilder.CollectionParameter <Address>("collectionComplex");
functionBuilder.EntityParameter <Customer>("entity");
functionBuilder.CollectionEntityParameter <Customer>("collectionEntity");
functionBuilder.Returns <bool>();
IEdmModel model = builder.GetEdmModel();
// Assert
Assert.Equal(1, model.SchemaElements.OfType <IEdmFunction>().Count());
IEdmFunction function = Assert.Single(model.SchemaElements.OfType <IEdmFunction>());
Assert.False(function.IsComposable);
Assert.True(function.IsBound);
Assert.Equal("FunctionName", function.Name);
Assert.NotNull(function.ReturnType);
Assert.Equal(13, function.Parameters.Count());
function.AssertHasParameter(model, BindingParameterConfiguration.DefaultBindingParameterName, typeof(Customer), true);
function.AssertHasParameter(model, parameterName: "primitive", parameterType: typeof(int), isNullable: false);
function.AssertHasParameter(model, parameterName: "collectionPrimitive", parameterType: typeof(IList <int>), isNullable: false);
function.AssertHasParameter(model, parameterName: "nullablePrimitive", parameterType: typeof(bool?), isNullable: true);
function.AssertHasParameter(model, parameterName: "nullableCollectionPrimitive", parameterType: typeof(IList <bool?>), isNullable: true);
function.AssertHasParameter(model, parameterName: "enum", parameterType: typeof(Color), isNullable: false);
function.AssertHasParameter(model, parameterName: "collectionEnum", parameterType: typeof(IList <Color>), isNullable: false);
function.AssertHasParameter(model, parameterName: "nullableEnum", parameterType: typeof(Color?), isNullable: true);
function.AssertHasParameter(model, parameterName: "nullableCollectionEnum", parameterType: typeof(IList <Color?>), isNullable: true);
function.AssertHasParameter(model, parameterName: "complex", parameterType: typeof(Address), isNullable: true);
function.AssertHasParameter(model, parameterName: "collectionComplex", parameterType: typeof(IList <Address>), isNullable: true);
function.AssertHasParameter(model, parameterName: "entity", parameterType: typeof(Customer), isNullable: true);
function.AssertHasParameter(model, parameterName: "collectionEntity", parameterType: typeof(IList <Customer>), isNullable: true);
}