public void CanCreateFunctionWithNoArguments() { // Arrange // Act ODataModelBuilder builder = new ODataModelBuilder(); builder.Namespace = "MyNamespace"; builder.ContainerName = "MyContainer"; FunctionConfiguration function = builder.Function("Format"); // Assert Assert.Equal("Format", function.Name); Assert.Equal(ProcedureKind.Function, function.Kind); Assert.NotNull(function.Parameters); Assert.Empty(function.Parameters); Assert.Null(function.ReturnType); Assert.False(function.IsSideEffecting); Assert.False(function.IsComposable); Assert.False(function.IsBindable); Assert.False(function.SupportedInFilter); Assert.False(function.SupportedInOrderBy); Assert.Equal("MyNamespace.Format", function.FullyQualifiedName); Assert.NotNull(builder.Procedures); Assert.Equal(1, builder.Procedures.Count()); }
public virtual FunctionConfiguration Function(string name) { FunctionConfiguration function = new FunctionConfiguration(this, name); _procedures.Add(function); return(function); }
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 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 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 CanCreateEdmModel_WithNonBindableFunction() { // Arrange ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>(); // Act FunctionConfiguration functionConfiguration = builder.Function("FunctionName"); functionConfiguration.ReturnsFromEntitySet <Customer>("Customers"); IEdmModel model = builder.GetEdmModel(); // Assert IEdmEntityContainer container = model.EntityContainer; Assert.NotNull(container); Assert.Equal(1, container.Elements.OfType <IEdmFunctionImport>().Count()); Assert.Equal(1, container.Elements.OfType <IEdmEntitySet>().Count()); IEdmFunctionImport functionImport = Assert.Single(container.Elements.OfType <IEdmFunctionImport>()); IEdmFunction function = functionImport.Function; Assert.False(function.IsComposable); Assert.False(function.IsBound); Assert.Equal("FunctionName", function.Name); Assert.NotNull(function.ReturnType); Assert.NotNull(functionImport.EntitySet); Assert.Equal("Customers", (functionImport.EntitySet as IEdmEntitySetReferenceExpression).ReferencedEntitySet.Name); Assert.Equal( typeof(Customer).FullName, (functionImport.EntitySet as IEdmEntitySetReferenceExpression).ReferencedEntitySet.EntityType().FullName()); Assert.Empty(function.Parameters); }
public void CanCreateFunctionWithEntityReturnType() { // Arrange // Act ODataModelBuilder builder = new ODataModelBuilder(); FunctionConfiguration createGoodCustomer = builder.Function("CreateGoodCustomer").ReturnsFromEntitySet <Customer>("GoodCustomers"); FunctionConfiguration createBadCustomers = builder.Function("CreateBadCustomers").ReturnsCollectionFromEntitySet <Customer>("BadCustomers"); // Assert EntityTypeConfiguration customer = createGoodCustomer.ReturnType as EntityTypeConfiguration; Assert.NotNull(customer); Assert.Equal(typeof(Customer).FullName, customer.FullName); EntitySetConfiguration goodCustomers = builder.EntitySets.SingleOrDefault(s => s.Name == "GoodCustomers"); Assert.NotNull(goodCustomers); Assert.Same(createGoodCustomer.NavigationSource, goodCustomers); CollectionTypeConfiguration customers = createBadCustomers.ReturnType as CollectionTypeConfiguration; Assert.NotNull(customers); customer = customers.ElementType as EntityTypeConfiguration; Assert.NotNull(customer); EntitySetConfiguration badCustomers = builder.EntitySets.SingleOrDefault(s => s.Name == "BadCustomers"); Assert.NotNull(badCustomers); Assert.Same(createBadCustomers.NavigationSource, badCustomers); }
public void CanCreateFunctionWithNonbindingParameters() { // Arrange // Act ODataModelBuilder builder = new ODataModelBuilder(); FunctionConfiguration function = builder.Function("MyFunction"); function.Parameter <string>("p0"); function.Parameter <int>("p1"); function.Parameter <Address>("p2"); function.CollectionParameter <string>("p3"); function.CollectionParameter <int>("p4"); function.CollectionParameter <ZipCode>("p5"); ParameterConfiguration[] parameters = function.Parameters.ToArray(); ComplexTypeConfiguration[] complexTypes = builder.StructuralTypes.OfType <ComplexTypeConfiguration>().ToArray(); // Assert Assert.Equal(2, complexTypes.Length); Assert.Equal(typeof(Address).FullName, complexTypes[0].FullName); Assert.Equal(typeof(ZipCode).FullName, complexTypes[1].FullName); Assert.Equal(6, parameters.Length); Assert.Equal("p0", parameters[0].Name); Assert.Equal("Edm.String", parameters[0].TypeConfiguration.FullName); Assert.Equal("p1", parameters[1].Name); Assert.Equal("Edm.Int32", parameters[1].TypeConfiguration.FullName); Assert.Equal("p2", parameters[2].Name); Assert.Equal(typeof(Address).FullName, parameters[2].TypeConfiguration.FullName); Assert.Equal("p3", parameters[3].Name); Assert.Equal("Collection(Edm.String)", parameters[3].TypeConfiguration.FullName); Assert.Equal("p4", parameters[4].Name); Assert.Equal("Collection(Edm.Int32)", parameters[4].TypeConfiguration.FullName); Assert.Equal("p5", parameters[5].Name); Assert.Equal(string.Format("Collection({0})", typeof(ZipCode).FullName), parameters[5].TypeConfiguration.FullName); }
public void CanCreateFunctionWithComplexReturnType() { // Arrange // Act ODataModelBuilder builder = new ODataModelBuilder(); FunctionConfiguration createAddress = builder.Function("CreateAddress").Returns <Address>(); FunctionConfiguration createAddresses = builder.Function("CreateAddresses").ReturnsCollection <Address>(); // Assert ComplexTypeConfiguration address = createAddress.ReturnType as ComplexTypeConfiguration; Assert.NotNull(address); Assert.Equal(typeof(Address).FullName, address.FullName); Assert.Null(createAddress.NavigationSource); CollectionTypeConfiguration addresses = createAddresses.ReturnType as CollectionTypeConfiguration; Assert.NotNull(addresses); Assert.Equal(string.Format("Collection({0})", typeof(Address).FullName), addresses.FullName); address = addresses.ElementType as ComplexTypeConfiguration; Assert.NotNull(address); Assert.Equal(typeof(Address).FullName, address.FullName); Assert.Null(createAddresses.NavigationSource); }
public void CanCreateFunctionWithNonbindingParametersAsNullable() { // Arrange & Act ODataModelBuilder builder = new ODataModelBuilder(); FunctionConfiguration function = builder.Function("MyFunction"); function.Parameter <string>("p0"); function.Parameter <string>("p1").OptionalParameter = false; function.Parameter <int>("p2").OptionalParameter = true; function.Parameter <int>("p3"); function.Parameter <Address>("p4"); function.Parameter <Address>("p5").OptionalParameter = false; function.CollectionParameter <ZipCode>("p6"); function.CollectionParameter <ZipCode>("p7").OptionalParameter = false; Dictionary <string, ParameterConfiguration> parameters = function.Parameters.ToDictionary(e => e.Name, e => e); // Assert Assert.True(parameters["p0"].OptionalParameter); Assert.False(parameters["p1"].OptionalParameter); Assert.True(parameters["p2"].OptionalParameter); Assert.False(parameters["p3"].OptionalParameter); Assert.True(parameters["p4"].OptionalParameter); Assert.False(parameters["p5"].OptionalParameter); Assert.True(parameters["p6"].OptionalParameter); Assert.False(parameters["p7"].OptionalParameter); }
/// <summary> /// Creates a new Function that binds to Collection(EntityType). /// </summary> /// <param name="name">The name of the Function</param> /// <returns>A <see cref="FunctionConfiguration"/> to allow further configuration of the Function.</returns> public FunctionConfiguration Function(string name) { Contract.Assert(ModelBuilder != null); FunctionConfiguration configuration = ModelBuilder.Function(name); configuration.SetBindingParameter(BindingParameterConfiguration.DefaultBindingParameterName, this); return(configuration); }
/// <summary> /// Creates a new Function that sometimes binds to Collection(EntityType). /// </summary> /// <param name="name">The name of the Function</param> /// <returns>A <see cref="FunctionConfiguration"/> to allow further configuration of the Function.</returns> public FunctionConfiguration TransientFunction(string name) { Contract.Assert(ModelBuilder != null); FunctionConfiguration configuration = ModelBuilder.Function(name); configuration.SetBindingParameter(BindingParameterConfiguration.DefaultBindingParameterName, this, alwaysBindable: false); return(configuration); }
public void CanCreateFunctionWithReturnTypeAsNullableByDefault() { // Arrange & Act ODataModelBuilder builder = new ODataModelBuilder(); FunctionConfiguration function = builder.Function("MyFunction").Returns <Address>(); // Assert Assert.True(function.OptionalReturn); }
/// <summary> /// Create a Function that binds to this EntityType. /// </summary> /// <param name="name">The name of the function.</param> /// <returns>The FunctionConfiguration to allow further configuration of the new Function.</returns> public FunctionConfiguration Function(string name) { Contract.Assert(_configuration != null && _configuration.ModelBuilder != null); FunctionConfiguration function = _configuration.ModelBuilder.Function(name); function.SetBindingParameter(BindingParameterConfiguration.DefaultBindingParameterName, _configuration); return(function); }
public void HasFeedFunctionLink_ThrowsException_OnNonBindableFunctions() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); FunctionConfiguration function = builder.Function("NoBindableFunction"); // Act & Assert Assert.Throws <InvalidOperationException>( () => function.HasFeedFunctionLink(ctx => new Uri("http://any"), followsConventions: false), "To register a function link factory, functions must be bindable to the collection of entity. " + "Function 'NoBindableFunction' does not meet this requirement."); }
public void HasFunctionLink_ThrowsException_OnNoBoundToEntityFunctions() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); EntityTypeConfiguration <Customer> customer = builder.EntityType <Customer>(); FunctionConfiguration function = customer.Collection.Function("CollectionFunction"); // Act & Assert Assert.Throws <InvalidOperationException>( () => function.HasFunctionLink(ctx => new Uri("http://any"), followsConventions: false), "To register a function link factory, functions must be bindable to a single entity. " + "Function 'CollectionFunction' does not meet this requirement."); }
public void CanCreateFunctionWithPrimitiveCollectionReturnType() { // Arrange // Act ODataModelBuilder builder = new ODataModelBuilder(); FunctionConfiguration function = builder.Function("CreateMessages"); function.ReturnsCollection <string>(); // Assert Assert.NotNull(function.ReturnType); Assert.Equal("Collection(Edm.String)", function.ReturnType.FullName); }
public void Parameter_ThrowsInvalidOperationIfGenericArgumentIsDateTime(Type type) { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); FunctionConfiguration function = builder.Function("Format"); MethodInfo method = typeof(FunctionConfiguration) .GetMethod("Parameter", new[] { typeof(string) }) .MakeGenericMethod(type); // Act & Assert Assert.Throws <InvalidOperationException>( () => method.Invoke(function, new[] { "test" }), string.Format("The type '{0}' is not a supported parameter type for the parameter test.", type.FullName)); }
public void Returns_ThrowsInvalidOperationIfGenericArgumentIsDateTime(Type type) { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); FunctionConfiguration function = builder.Function("Format"); MethodInfo method = typeof(FunctionConfiguration) .GetMethod("Returns") .MakeGenericMethod(type); // Act & Assert Assert.Throws <InvalidOperationException>( () => method.Invoke(function, new object[] { }), string.Format("The type '{0}' is not a supported return type.", type.FullName)); }
public void CanCreateFunctionThatBindsToEntityCollection() { // Arrange // Act ODataModelBuilder builder = new ODataModelBuilder(); EntityTypeConfiguration <Customer> customer = builder.EntityType <Customer>(); FunctionConfiguration sendEmail = customer.Collection.Function("SendEmail"); // Assert Assert.True(sendEmail.IsBindable); Assert.NotNull(sendEmail.Parameters); Assert.Equal(1, sendEmail.Parameters.Count()); Assert.Equal(BindingParameterConfiguration.DefaultBindingParameterName, sendEmail.Parameters.Single().Name); Assert.Equal(string.Format("Collection({0})", typeof(Customer).FullName), sendEmail.Parameters.Single().TypeConfiguration.FullName); }
private static EdmOperationImport CreateFunctionImport( FunctionConfiguration function, EdmEntityContainer container, IEdmTypeReference returnReference, IEdmExpression expression, IEdmPathExpression pathExpression) { EdmFunction operation = new EdmFunction( function.Namespace, function.Name, returnReference, function.IsBindable, pathExpression, function.IsComposable); return(new EdmFunctionImport(container, function.Name, operation, expression, includeInServiceDocument: function.IncludeInServiceDocument)); }
public void DollarMetadata_Works_WithFunctionParameterNullable_ReturnTypeNullable() { // Arrange const string expectMetadata = @"<Schema Namespace='Default' xmlns='http://docs.oasis-open.org/odata/ns/edm'> <Function Name='NullableFunction' IsBound='true'> <Parameter Name='bindingParameter' Type='System.Web.OData.Formatter.FormatterPerson' /> <Parameter Name='param' Type='Edm.String' Unicode='false' /> <ReturnType Type='System.Web.OData.Formatter.FormatterAddress' /> </Function> <Function Name='NonNullableFunction' IsBound='true'> <Parameter Name='bindingParameter' Type='System.Web.OData.Formatter.FormatterPerson' /> <Parameter Name='param' Type='Edm.String' Nullable='false' Unicode='false' /> <ReturnType Type='System.Web.OData.Formatter.FormatterAddress' Nullable='false' /> </Function> <EntityContainer Name='Container' /> </Schema> </edmx:DataServices> </edmx:Edmx>"; ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); EntityTypeConfiguration <FormatterPerson> person = builder.EntityType <FormatterPerson>(); FunctionConfiguration function = person.Function("NullableFunction").Returns <FormatterAddress>(); function.Parameter <string>("param"); function = person.Function("NonNullableFunction").Returns <FormatterAddress>(); function.OptionalReturn = false; function.Parameter <string>("param").OptionalParameter = false; IEdmModel model = builder.GetEdmModel(); var config = new[] { typeof(MetadataController) }.GetHttpConfiguration(); config.MapODataServiceRoute(model); HttpServer server = new HttpServer(config); HttpClient client = new HttpClient(server); // Act var response = client.GetAsync("http://localhost/$metadata").Result; // Assert Assert.True(response.IsSuccessStatusCode); Assert.Equal("application/xml", response.Content.Headers.ContentType.MediaType); Assert.Contains(expectMetadata.Replace("'", "\""), response.Content.ReadAsStringAsync().Result); }
public void HasFunctionLink_SetsFollowsConventions(bool value) { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); FunctionConfiguration function = new FunctionConfiguration(builder, "IgnoreFunction"); Mock <IEdmTypeConfiguration> bindingParameterTypeMock = new Mock <IEdmTypeConfiguration>(); bindingParameterTypeMock.Setup(o => o.Kind).Returns(EdmTypeKind.Entity); IEdmTypeConfiguration bindingParameterType = bindingParameterTypeMock.Object; function.SetBindingParameter("IgnoreParameter", bindingParameterType); // Act function.HasFunctionLink((a) => { throw new NotImplementedException(); }, followsConventions: value); // Assert Assert.Equal(value, function.FollowsConventions); }
private static void AddProcedureLinkBuilder(IEdmModel model, IEdmOperation operation, ProcedureConfiguration procedure) { ActionConfiguration actionConfiguration = procedure as ActionConfiguration; IEdmAction action = operation as IEdmAction; FunctionConfiguration functionConfiguration = procedure as FunctionConfiguration; IEdmFunction function = operation as IEdmFunction; if (procedure.BindingParameter.TypeConfiguration.Kind == EdmTypeKind.Entity) { if (actionConfiguration != null && actionConfiguration.GetActionLink() != null && action != null) { model.SetActionLinkBuilder( action, new ActionLinkBuilder(actionConfiguration.GetActionLink(), actionConfiguration.FollowsConventions)); } else if (functionConfiguration != null && functionConfiguration.GetFunctionLink() != null && function != null) { model.SetFunctionLinkBuilder( function, new FunctionLinkBuilder(functionConfiguration.GetFunctionLink(), functionConfiguration.FollowsConventions)); } } else if (procedure.BindingParameter.TypeConfiguration.Kind == EdmTypeKind.Collection) { CollectionTypeConfiguration collectionTypeConfiguration = (CollectionTypeConfiguration)procedure.BindingParameter.TypeConfiguration; if (collectionTypeConfiguration.ElementType.Kind == EdmTypeKind.Entity) { if (actionConfiguration != null && actionConfiguration.GetFeedActionLink() != null && action != null) { model.SetActionLinkBuilder( action, new ActionLinkBuilder(actionConfiguration.GetFeedActionLink(), actionConfiguration.FollowsConventions)); } else if (functionConfiguration != null && functionConfiguration.GetFeedFunctionLink() != null && function != null) { model.SetFunctionLinkBuilder( function, new FunctionLinkBuilder(functionConfiguration.GetFeedFunctionLink(), functionConfiguration.FollowsConventions)); } } } }
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 CanCreateFunctionWithCollectionReturnTypeViaEntitySetPath() { // Arrange ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>(); EntityTypeConfiguration <Customer> customer = builder.EntityType <Customer>(); EntityTypeConfiguration <Order> order = builder.EntityType <Order>(); customer.HasMany <Order>(c => c.Orders); FunctionConfiguration getOrders = customer.Function("GetOrders").ReturnsCollectionViaEntitySetPath <Order>("bindingParameter/Orders"); // Act IEdmModel model = builder.GetEdmModel(); // Assert IEdmFunction function = Assert.Single(model.SchemaElements.OfType <IEdmFunction>()); Assert.Equal(EdmExpressionKind.Path, function.EntitySetPath.ExpressionKind); Assert.Equal("bindingParameter/Orders", string.Join("/", ((IEdmPathExpression)(function.EntitySetPath)).Path)); }
public void CanCreateFunctionWithNonbindingParameters_AddParameterNonGenericMethod() { // Arrange // Act ODataModelBuilder builder = new ODataModelBuilder(); FunctionConfiguration function = builder.Function("MyFunction"); function.Parameter(typeof(string), "p0"); function.Parameter(typeof(int), "p1"); function.Parameter(typeof(Address), "p2"); ParameterConfiguration[] parameters = function.Parameters.ToArray(); // Assert Assert.Equal(3, parameters.Length); Assert.Equal("p0", parameters[0].Name); Assert.Equal("Edm.String", parameters[0].TypeConfiguration.FullName); Assert.Equal("p1", parameters[1].Name); Assert.Equal("Edm.Int32", parameters[1].TypeConfiguration.FullName); Assert.Equal("p2", parameters[2].Name); Assert.Equal(typeof(Address).FullName, parameters[2].TypeConfiguration.FullName); }
public void UnboundFunction_ForEnumTypeInODataConventionModelBuilder() { // Arrange ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); FunctionConfiguration functionConfiguration = builder.Function("UnboundFunction"); functionConfiguration.Parameter <Color>("Color"); functionConfiguration.ReturnsCollection <Color>(); // Act & Assert IEdmModel model = builder.GetEdmModel(); IEdmFunctionImport functionImport = model.EntityContainer.OperationImports().Single(o => o.Name == "UnboundFunction") as IEdmFunctionImport; IEdmTypeReference color = functionImport.Function.Parameters.Single(p => p.Name == "Color").Type; IEdmTypeReference returnType = functionImport.Function.ReturnType; IEdmEnumType colorType = model.SchemaElements.OfType <IEdmEnumType>().Single(e => e.Name == "Color"); Assert.Same(colorType, color.Definition); Assert.True(returnType.IsCollection()); Assert.Same(colorType, returnType.AsCollection().ElementType().Definition); }
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 WhenFunctionLinksNotManuallyConfigured_ConventionBasedBuilderUsesConventions() { // Arrange string uriTemplate = "http://server/Movies({0})/Default.Watch(param=@param)"; Uri expectedUri = new Uri(string.Format(uriTemplate, 1)); ODataModelBuilder builder = new ODataConventionModelBuilder(); EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType; FunctionConfiguration watch = movie.Function("Watch").Returns <int>(); watch.Parameter <string>("param"); IEdmModel model = builder.GetEdmModel(); HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://server/Movies"); HttpConfiguration configuration = new HttpConfiguration(); string routeName = "Route"; configuration.MapODataServiceRoute(routeName, null, model); request.SetConfiguration(configuration); request.ODataProperties().RouteName = routeName; UrlHelper urlHelper = new UrlHelper(request); // Act IEdmEntityType movieType = model.SchemaElements.OfType <IEdmEntityType>().SingleOrDefault(); IEdmEntityContainer container = model.SchemaElements.OfType <IEdmEntityContainer>().SingleOrDefault(); IEdmFunction watchFunction = Assert.Single(model.SchemaElements.OfType <IEdmFunction>()); // Guard IEdmEntitySet entitySet = container.EntitySets().SingleOrDefault(); ODataSerializerContext serializerContext = new ODataSerializerContext { Model = model, NavigationSource = entitySet, Url = urlHelper }; EntityInstanceContext context = new EntityInstanceContext(serializerContext, movieType.AsReference(), new Movie { ID = 1, Name = "Avatar" }); FunctionLinkBuilder functionLinkBuilder = model.GetAnnotationValue <FunctionLinkBuilder>(watchFunction); //Assert Assert.Equal(expectedUri, watch.GetFunctionLink()(context)); Assert.NotNull(functionLinkBuilder); Assert.Equal(expectedUri, functionLinkBuilder.BuildFunctionLink(context)); }