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.AddProcedure(configuration);
builder.AddEntityType(entityType);
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
var function = Assert.Single(model.SchemaElements.OfType <IEdmFunction>());
FunctionLinkBuilder functionLinkBuilder = model.GetFunctionLinkBuilder(function);
Assert.NotNull(functionLinkBuilder);
Assert.Equal(value, functionLinkBuilder.FollowsConventions);
}
public void FollowsConventions_IsSpecifiedValue(bool value)
{
// Arrange
FunctionLinkBuilder builder = new FunctionLinkBuilder((EntityInstanceContext a) => { throw new NotImplementedException(); },
followsConventions: value);
// Act
bool followsConventions = builder.FollowsConventions;
// Assert
Assert.Equal(value, followsConventions);
}
/// <summary>
/// Register a factory that creates functions links.
/// </summary>
public FunctionConfiguration HasFunctionLink(Func <EntityInstanceContext, Uri> functionLinkFactory, bool followsConventions)
{
if (functionLinkFactory == null)
{
throw new ArgumentNullException("functionLinkFactory");
}
if (!IsBindable || BindingParameter.TypeConfiguration.Kind != EdmTypeKind.Entity)
{
throw Error.InvalidOperation(SRResources.HasFunctionLinkRequiresBindToEntity, Name);
}
ProcedureLinkBuilder = new FunctionLinkBuilder(functionLinkFactory, followsConventions);
FollowsConventions = followsConventions;
return(this);
}
public void BuildFunctionLink_ForFeed_ReturnsLink()
{
// Arrange
FunctionLinkBuilder builder = new FunctionLinkBuilder((FeedContext a) => new Uri("http://localhost:456"),
followsConventions: true);
EntityInstanceContext entityContext = new EntityInstanceContext();
FeedContext feedContext = new FeedContext();
// Act
Uri link = builder.BuildFunctionLink(entityContext);
Uri feedLink = builder.BuildFunctionLink(feedContext);
// Assert
Assert.Null(link);
Assert.NotNull(feedLink);
Assert.Equal("http://localhost:456/", feedLink.AbsoluteUri);
}
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));
}
public void WhenFeedActionLinksNotManuallyConfigured_ConventionBasedBuilderUsesConventions()
{
// Arrange
Uri expectedUri = new Uri("http://server/Movies/Default.Watch(param=@param)");
ODataModelBuilder builder = new ODataConventionModelBuilder();
EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType;
FunctionConfiguration watch = movie.Collection.Function("Watch").Returns <int>(); // function bound to collection
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
IEdmEntityContainer container = model.SchemaElements.OfType <IEdmEntityContainer>().SingleOrDefault();
IEdmFunction watchFunction = Assert.Single(model.SchemaElements.OfType <IEdmFunction>()); // Guard
IEdmEntitySet entitySet = container.EntitySets().SingleOrDefault();
FeedContext context = new FeedContext
{
EntitySetBase = entitySet,
Url = urlHelper,
Request = request
};
FunctionLinkBuilder functionLinkBuilder = model.GetAnnotationValue <FunctionLinkBuilder>(watchFunction);
//Assert
Assert.Equal(expectedUri, watch.GetFeedFunctionLink()(context));
Assert.NotNull(functionLinkBuilder);
Assert.Equal(expectedUri, functionLinkBuilder.BuildFunctionLink(context));
}
public void CanManuallyConfigureFeedFunctionLinkFactory()
{
// Arrange
Uri expectedUri = new Uri("http://localhost/service/Customers/Reward");
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration <Customer> customer = builder.EntitySet <Customer>("Customers").EntityType;
customer.HasKey(c => c.CustomerId);
customer.Property(c => c.Name);
FunctionConfiguration reward = customer.Collection.Function("Reward").Returns <int>();
reward.HasFeedFunctionLink(ctx => expectedUri, followsConventions: false);
IEdmModel model = builder.GetEdmModel();
// Act
IEdmFunction rewardFuntion = Assert.Single(model.SchemaElements.OfType <IEdmFunction>()); // Guard
FunctionLinkBuilder functionLinkBuilder = model.GetAnnotationValue <FunctionLinkBuilder>(rewardFuntion);
FeedContext context = new FeedContext();
//Assert
Assert.Equal(expectedUri, reward.GetFeedFunctionLink()(context));
Assert.NotNull(functionLinkBuilder);
Assert.Equal(expectedUri, functionLinkBuilder.BuildFunctionLink(context));
}
public void GetFunctionLinkBuilderForFeed_After_SetActionLinkBuilder()
{
// Arrange
IEdmModel model = new EdmModel();
IEdmFunction function = new Mock<IEdmFunction>().Object;
FunctionLinkBuilder builder = new FunctionLinkBuilder((FeedContext _) => null, followsConventions: false);
// Act
model.SetFunctionLinkBuilder(function, builder);
var result = model.GetFunctionLinkBuilder(function);
// Assert
Assert.Same(builder, result);
}
public static void SetFunctionLinkBuilder(this IEdmModel model, IEdmFunction function, FunctionLinkBuilder functionLinkBuilder)
{
if (model == null)
{
throw Error.ArgumentNull("model");
}
model.SetAnnotationValue(function, functionLinkBuilder);
}
public void CreateODataFunction_OmitsAction_WhenFollowingConventions(TestODataMetadataLevel metadataLevel)
{
// Arrange
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
IEdmFunction function = new EdmFunction("NS", "Function", returnType, isBound: true, entitySetPathExpression: null, isComposable: false);
FunctionLinkBuilder linkBuilder = new FunctionLinkBuilder((EntityInstanceContext a) => new Uri("aa://Ignore"),
followsConventions: true);
IEdmDirectValueAnnotationsManager annotationsManager = CreateFakeAnnotationsManager();
annotationsManager.SetFunctionLinkBuilder(function, linkBuilder);
IEdmModel model = CreateFakeModel(annotationsManager);
UrlHelper url = CreateMetadataLinkFactory("http://IgnoreMetadataPath");
EntityInstanceContext context = CreateContext(model, url);
context.SerializerContext.MetadataLevel = (ODataMetadataLevel)metadataLevel;
// Act
ODataFunction actualFunction = _serializer.CreateODataFunction(function, context);
// Assert
Assert.Null(actualFunction);
}
public void CreateODataFunction_IncludesTarget_IfDoesnotFollowODataConvention()
{
// Arrange
Uri expectedTarget = new Uri("aa://Target");
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
IEdmFunction function = new EdmFunction("NS", "Function", returnType, isBound: true, entitySetPathExpression: null, isComposable: false);
FunctionLinkBuilder linkBuilder = new FunctionLinkBuilder((EntityInstanceContext a) => expectedTarget, followsConventions: false);
IEdmDirectValueAnnotationsManager annotationsManager = CreateFakeAnnotationsManager();
annotationsManager.SetFunctionLinkBuilder(function, linkBuilder);
IEdmModel model = CreateFakeModel(annotationsManager);
UrlHelper url = CreateMetadataLinkFactory("http://IgnoreMetadataPath");
EntityInstanceContext context = CreateContext(model, url);
context.SerializerContext.MetadataLevel = (ODataMetadataLevel)TestODataMetadataLevel.FullMetadata;
// Act
ODataFunction actualFunction = _serializer.CreateODataFunction(function, context);
// Assert
Assert.NotNull(actualFunction);
Assert.Equal(expectedTarget, actualFunction.Target);
}
public void CreateODataFunction_IncludesEverything_ForFullMetadata()
{
// Arrange
string expectedTarget = "aa://Target";
string expectedMetadataPrefix = "http://Metadata";
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
IEdmFunction function = new EdmFunction("NS", "Function", returnType, isBound: true, entitySetPathExpression: null, isComposable: false);
FunctionLinkBuilder linkBuilder = new FunctionLinkBuilder((EntityInstanceContext a) => new Uri(expectedTarget),
followsConventions: false);
IEdmDirectValueAnnotationsManager annotationsManager = CreateFakeAnnotationsManager();
annotationsManager.SetFunctionLinkBuilder(function, linkBuilder);
annotationsManager.SetIsAlwaysBindable(function);
IEdmModel model = CreateFakeModel(annotationsManager);
UrlHelper url = CreateMetadataLinkFactory(expectedMetadataPrefix);
EntityInstanceContext context = CreateContext(model, url);
context.SerializerContext.MetadataLevel = ODataMetadataLevel.FullMetadata;
// Act
ODataFunction actualFunction = _serializer.CreateODataFunction(function, context);
// Assert
string expectedMetadata = expectedMetadataPrefix + "#NS.Function";
ODataFunction expectedFunction = new ODataFunction
{
Metadata = new Uri(expectedMetadata),
Target = new Uri(expectedTarget),
Title = "Function"
};
AssertEqual(actualFunction, actualFunction);
}
public static FunctionLinkBuilder GetFunctionLinkBuilder(this IEdmModel model, IEdmFunction function)
{
if (model == null)
{
throw Error.ArgumentNull("model");
}
if (function == null)
{
throw Error.ArgumentNull("function");
}
FunctionLinkBuilder functionLinkBuilder = model.GetAnnotationValue<FunctionLinkBuilder>(function);
if (functionLinkBuilder == null)
{
if (function.Parameters != null)
{
if (function.Parameters.First().Type.IsEntity())
{
functionLinkBuilder = new FunctionLinkBuilder(
(EntityInstanceContext entityInstanceContext) =>
entityInstanceContext.GenerateFunctionLink(function),
followsConventions: true);
}
else if (function.Parameters.First().Type.IsCollection())
{
functionLinkBuilder =
new FunctionLinkBuilder(
(FeedContext feedContext) => feedContext.GenerateFunctionLink(function),
followsConventions: true);
}
}
model.SetFunctionLinkBuilder(function, functionLinkBuilder);
}
return functionLinkBuilder;
}
