public void WhenActionLinksNotManuallyConfigured_ConventionBasedBuilderUsesConventions()
{
// Arrange
string uriTemplate = "http://server/Movies({0})/Watch";
Uri expectedUri = new Uri(string.Format(uriTemplate, 1));
ODataModelBuilder builder = new ODataConventionModelBuilder();
EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType;
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://server/Movies");
HttpConfiguration configuration = new HttpConfiguration();
configuration.Routes.MapHttpRoute(ODataRouteNames.InvokeBoundAction, "{controller}({boundId})/{odataAction}");
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = configuration;
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = new HttpRouteData(new HttpRoute());
UrlHelper urlHelper = new UrlHelper(request);
// Act
ActionConfiguration watch = movie.Action("Watch");
IEdmModel model = builder.GetEdmModel();
IEdmEntityType movieType = model.SchemaElements.OfType <IEdmEntityType>().SingleOrDefault();
IEdmEntityContainer container = model.SchemaElements.OfType <IEdmEntityContainer>().SingleOrDefault();
IEdmFunctionImport watchAction = container.FunctionImports().SingleOrDefault();
IEdmEntitySet entitySet = container.EntitySets().SingleOrDefault();
EntityInstanceContext <Movie> context = new EntityInstanceContext <Movie>(model, entitySet, movieType, urlHelper, new Movie {
ID = 1, Name = "Avatar"
}, false);
ActionLinkBuilder actionLinkBuilder = model.GetAnnotationValue <ActionLinkBuilder>(watchAction);
//Assert
Assert.Equal(expectedUri, watch.GetActionLink()(context));
Assert.NotNull(actionLinkBuilder);
Assert.Equal(expectedUri, actionLinkBuilder.BuildActionLink(context));
}
public void ActionLink_PreservesFollowsConventions(bool value)
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
ActionConfiguration configuration = new ActionConfiguration(builder, "IgnoreAction");
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,
alwaysBindable: false);
configuration.HasActionLink((a) => { throw new NotImplementedException(); }, followsConventions: value);
builder.AddProcedure(configuration);
builder.AddEntity(entityType);
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
IEdmFunctionImport functionImport =
model.EntityContainers().Single().Elements.OfType <IEdmFunctionImport>().Single();
ActionLinkBuilder actionLinkBuilder = model.GetActionLinkBuilder(functionImport);
Assert.Equal(value, actionLinkBuilder.FollowsConventions);
}
public void CanManuallyConfigureActionLinkFactory()
{
// 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
ActionConfiguration reward = customer.Action("Reward");
reward.HasActionLink(ctx => new Uri(string.Format(uriTemplate, ctx.GetPropertyValue("CustomerId"))),
followsConventions: false);
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
});
IEdmFunctionImport rewardAction = model.SchemaElements.OfType <IEdmEntityContainer>().SingleOrDefault().FunctionImports().SingleOrDefault();
ActionLinkBuilder actionLinkBuilder = model.GetAnnotationValue <ActionLinkBuilder>(rewardAction);
//Assert
Assert.Equal(expectedUri, reward.GetActionLink()(context));
Assert.NotNull(actionLinkBuilder);
Assert.Equal(expectedUri, actionLinkBuilder.BuildActionLink(context));
}
public void FollowsConventions_IsSpecifiedValue(bool value)
{
// Arrange
ActionLinkBuilder builder = new ActionLinkBuilder((a) => { throw new NotImplementedException(); },
followsConventions: value);
// Act
bool followsConventions = builder.FollowsConventions;
// Assert
Assert.Equal(value, followsConventions);
}
public void FollowsConventions_IsSpecifiedValue(bool value)
{
// Arrange
ActionLinkBuilder builder = new ActionLinkBuilder((a) => { throw new NotImplementedException(); },
followsConventions: value);
// Act
bool followsConventions = builder.FollowsConventions;
// Assert
Assert.Equal(value, followsConventions);
}
public void GetActionLinkBuilder_After_SetActionLinkBuilder()
{
// Arrange
IEdmModel model = new EdmModel();
IEdmEntityContainer container = new EdmEntityContainer("NS", "Container");
IEdmFunctionImport action = new Mock<IEdmFunctionImport>().Object;
ActionLinkBuilder builder = new ActionLinkBuilder(_=> null, followsConventions: false);
// Act
model.SetActionLinkBuilder(action, builder);
var result = model.GetActionLinkBuilder(action);
// Assert
Assert.Same(builder, result);
}
internal static ActionLinkBuilder GetActionLinkBuilder(this IEdmModel model, IEdmFunctionImport action)
{
if (model == null)
{
throw Error.ArgumentNull("model");
}
if (action == null)
{
throw Error.ArgumentNull("action");
}
ActionLinkBuilder annotation = model.GetAnnotationValue <ActionLinkBuilder>(action);
return(annotation);
}
public void WhenActionLinksNotManuallyConfigured_ConventionBasedBuilderUsesConventions()
{
// Arrange
string uriTemplate = "http://server/Movies({0})/Watch";
Uri expectedUri = new Uri(string.Format(uriTemplate, 1));
ODataModelBuilder builder = new ODataConventionModelBuilder();
EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType;
ActionConfiguration watch = movie.Action("Watch");
IEdmModel model = builder.GetEdmModel();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://server/Movies");
HttpConfiguration configuration = new HttpConfiguration();
string routeName = "Route";
configuration.Routes.MapODataRoute(routeName, null, model);
request.SetConfiguration(configuration);
request.SetODataRouteName(routeName);
UrlHelper urlHelper = new UrlHelper(request);
// Act
IEdmEntityType movieType = model.SchemaElements.OfType <IEdmEntityType>().SingleOrDefault();
IEdmEntityContainer container = model.SchemaElements.OfType <IEdmEntityContainer>().SingleOrDefault();
IEdmFunctionImport watchAction = container.FunctionImports().SingleOrDefault();
IEdmEntitySet entitySet = container.EntitySets().SingleOrDefault();
EntityInstanceContext <Movie> context = new EntityInstanceContext <Movie>()
{
EdmModel = model,
EntitySet = entitySet,
EntityType = movieType,
Url = urlHelper,
EntityInstance = new Movie {
ID = 1, Name = "Avatar"
},
SkipExpensiveAvailabilityChecks = false
};
ActionLinkBuilder actionLinkBuilder = model.GetAnnotationValue <ActionLinkBuilder>(watchAction);
//Assert
Assert.Equal(expectedUri, watch.GetActionLink()(context));
Assert.NotNull(actionLinkBuilder);
Assert.Equal(expectedUri, actionLinkBuilder.BuildActionLink(context));
}
public static ActionLinkBuilder GetActionLinkBuilder(this IEdmModel model, IEdmFunctionImport action)
{
if (model == null)
{
throw Error.ArgumentNull("model");
}
if (action == null)
{
throw Error.ArgumentNull("action");
}
ActionLinkBuilder actionLinkBuilder = model.GetAnnotationValue<ActionLinkBuilder>(action);
if (actionLinkBuilder == null)
{
actionLinkBuilder = new ActionLinkBuilder(entityInstanceContext => entityInstanceContext.GenerateActionLink(action), followsConventions: true);
model.SetActionLinkBuilder(action, actionLinkBuilder);
}
return actionLinkBuilder;
}
public static void SetActionLinkBuilder(this IEdmModel model, IEdmFunctionImport action, ActionLinkBuilder actionLinkBuilder)
{
if (model == null)
{
throw Error.ArgumentNull("model");
}
model.SetAnnotationValue(action, actionLinkBuilder);
}
public void CreateODataAction_OmitsTarget_WhenFollowingConventions(TestODataMetadataLevel metadataLevel)
{
// Arrange
IEdmEntityContainer container = CreateFakeContainer("IgnoreContainer");
IEdmFunctionImport functionImport = CreateFakeFunctionImport(container, "IgnoreAction");
ActionLinkBuilder linkBuilder = new ActionLinkBuilder((a) => new Uri("aa://Ignore"),
followsConventions: true);
IEdmDirectValueAnnotationsManager annotationsManager = CreateFakeAnnotationsManager();
annotationsManager.SetActionLinkBuilder(functionImport, linkBuilder);
IEdmModel model = CreateFakeModel(annotationsManager);
UrlHelper url = CreateMetadataLinkFactory("http://IgnoreMetadataPath");
EntityInstanceContext context = CreateContext(model, url);
context.SerializerContext.MetadataLevel = (ODataMetadataLevel)metadataLevel;
// Act
ODataAction actualAction = _serializer.CreateODataAction(functionImport, context);
// Assert
Assert.NotNull(actualAction);
Assert.Null(actualAction.Target);
}
public void CreateODataAction_IncludesTitle(TestODataMetadataLevel metadataLevel)
{
// Arrange
string expectedActionName = "Action";
IEdmEntityContainer container = CreateFakeContainer("IgnoreContainer");
IEdmFunctionImport functionImport = CreateFakeFunctionImport(container, expectedActionName);
ActionLinkBuilder linkBuilder = new ActionLinkBuilder((a) => new Uri("aa://IgnoreTarget"),
followsConventions: false);
IEdmDirectValueAnnotationsManager annotationsManager = CreateFakeAnnotationsManager();
annotationsManager.SetActionLinkBuilder(functionImport, linkBuilder);
IEdmModel model = CreateFakeModel(annotationsManager);
UrlHelper url = CreateMetadataLinkFactory("http://IgnoreMetadataPath");
EntityInstanceContext context = CreateContext(model, url);
context.SerializerContext.MetadataLevel = (ODataMetadataLevel)metadataLevel;
// Act
ODataAction actualAction = _serializer.CreateODataAction(functionImport, context);
// Assert
Assert.NotNull(actualAction);
Assert.Equal(expectedActionName, actualAction.Title);
}
public void CreateODataAction_SkipsAlwaysAvailableAction_PerShouldOmitAction()
{
// Arrange
IEdmFunctionImport functionImport = CreateFakeFunctionImport(true);
ActionLinkBuilder linkBuilder = new ActionLinkBuilder((a) => new Uri("aa://IgnoreTarget"),
followsConventions: true);
IEdmDirectValueAnnotationsManager annotationsManager = CreateFakeAnnotationsManager();
annotationsManager.SetActionLinkBuilder(functionImport, linkBuilder);
annotationsManager.SetIsAlwaysBindable(functionImport);
IEdmModel model = CreateFakeModel(annotationsManager);
EntityInstanceContext context = CreateContext(model);
context.SerializerContext.MetadataLevel = ODataMetadataLevel.MinimalMetadata;
// Act
ODataAction actualAction = _serializer.CreateODataAction(functionImport, context);
// Assert
Assert.Null(actualAction);
}
public void CreateODataAction_ForJsonLight_OmitsContainerName_PerCreateMetadataFragment()
{
// Arrange
string expectedMetadataPrefix = "http://Metadata";
string expectedActionName = "Action";
IEdmEntityContainer container = CreateFakeContainer("ContainerShouldNotAppearInResult");
IEdmFunctionImport functionImport = CreateFakeFunctionImport(container, expectedActionName);
ActionLinkBuilder linkBuilder = new ActionLinkBuilder((a) => new Uri("aa://IgnoreTarget"),
followsConventions: false);
IEdmDirectValueAnnotationsManager annotationsManager = CreateFakeAnnotationsManager();
annotationsManager.SetActionLinkBuilder(functionImport, linkBuilder);
annotationsManager.SetDefaultContainer(container);
IEdmModel model = CreateFakeModel(annotationsManager);
UrlHelper url = CreateMetadataLinkFactory(expectedMetadataPrefix);
EntityInstanceContext context = CreateContext(model, url);
context.SerializerContext.MetadataLevel = ODataMetadataLevel.MinimalMetadata;
// Act
ODataAction actualAction = _serializer.CreateODataAction(functionImport, context);
// Assert
Assert.NotNull(actualAction);
string expectedMetadata = expectedMetadataPrefix + "#" + expectedActionName;
AssertEqual(new Uri(expectedMetadata), actualAction.Metadata);
}
public void CreateODataAction_OmitsAction_WhenActionLinkBuilderReturnsNull()
{
// Arrange
IEdmEntityContainer container = CreateFakeContainer("IgnoreContainer");
IEdmFunctionImport functionImport = CreateFakeFunctionImport(container, "IgnoreAction");
ActionLinkBuilder linkBuilder = new ActionLinkBuilder((a) => null, followsConventions: false);
IEdmDirectValueAnnotationsManager annotationsManager = CreateFakeAnnotationsManager();
annotationsManager.SetActionLinkBuilder(functionImport, linkBuilder);
IEdmModel model = CreateFakeModel(annotationsManager);
EntityInstanceContext context = CreateContext(model);
context.SerializerContext.MetadataLevel = ODataMetadataLevel.MinimalMetadata;
// Act
ODataAction actualAction = _serializer.CreateODataAction(functionImport, context);
// Assert
Assert.Null(actualAction);
}
public void CreateODataAction_ForAtom_IncludesEverything()
{
// Arrange
string expectedContainerName = "Container";
string expectedActionName = "Action";
string expectedTarget = "aa://Target";
string expectedMetadataPrefix = "http://Metadata";
IEdmEntityContainer container = CreateFakeContainer(expectedContainerName);
IEdmFunctionImport functionImport = CreateFakeFunctionImport(container, expectedActionName,
isBindable: true);
ActionLinkBuilder linkBuilder = new ActionLinkBuilder((a) => new Uri(expectedTarget),
followsConventions: true);
IEdmDirectValueAnnotationsManager annotationsManager = CreateFakeAnnotationsManager();
annotationsManager.SetActionLinkBuilder(functionImport, linkBuilder);
annotationsManager.SetIsAlwaysBindable(functionImport);
annotationsManager.SetDefaultContainer(container);
IEdmModel model = CreateFakeModel(annotationsManager);
UrlHelper url = CreateMetadataLinkFactory(expectedMetadataPrefix);
EntityInstanceContext context = CreateContext(model, url);
context.SerializerContext.MetadataLevel = ODataMetadataLevel.Default;
// Act
ODataAction actualAction = _serializer.CreateODataAction(functionImport, context);
// Assert
string expectedMetadata = expectedMetadataPrefix + "#" + expectedContainerName + "." + expectedActionName;
ODataAction expectedAction = new ODataAction
{
Metadata = new Uri(expectedMetadata),
Target = new Uri(expectedTarget),
Title = expectedActionName
};
AssertEqual(expectedAction, actualAction);
}
public void CreateODataAction_OmitsTitle(TestODataMetadataLevel metadataLevel)
{
// Arrange
IEdmAction action = CreateFakeAction("IgnoreAction");
ActionLinkBuilder linkBuilder = new ActionLinkBuilder((a) => new Uri("aa://Ignore"),
followsConventions: false);
IEdmDirectValueAnnotationsManager annotationsManager = CreateFakeAnnotationsManager();
annotationsManager.SetActionLinkBuilder(action, linkBuilder);
IEdmModel model = CreateFakeModel(annotationsManager);
UrlHelper url = CreateMetadataLinkFactory("http://IgnoreMetadataPath");
EntityInstanceContext context = CreateContext(model, url);
context.SerializerContext.MetadataLevel = (ODataMetadataLevel)metadataLevel;
// Act
ODataAction actualAction = _serializer.CreateODataAction(action, context);
// Assert
Assert.NotNull(actualAction);
Assert.Null(actualAction.Title);
}
public void CreateODataAction_IncludesTarget(TestODataMetadataLevel metadataLevel, bool followsConventions)
{
// Arrange
Uri expectedTarget = new Uri("aa://Target");
IEdmEntityContainer container = CreateFakeContainer("IgnoreContainer");
IEdmFunctionImport functionImport = CreateFakeFunctionImport(container, "IgnoreAction");
ActionLinkBuilder linkBuilder = new ActionLinkBuilder((a) => expectedTarget, followsConventions);
IEdmDirectValueAnnotationsManager annotationsManager = CreateFakeAnnotationsManager();
annotationsManager.SetActionLinkBuilder(functionImport, linkBuilder);
IEdmModel model = CreateFakeModel(annotationsManager);
UrlHelper url = CreateMetadataLinkFactory("http://IgnoreMetadataPath");
EntityInstanceContext context = CreateContext(model, url);
// Act
ODataAction actualAction = _serializer.CreateODataAction(functionImport, context,
(ODataMetadataLevel)metadataLevel);
// Assert
Assert.NotNull(actualAction);
Assert.Equal(expectedTarget, actualAction.Target);
}
internal static bool ShouldOmitAction(IEdmFunctionImport action, IEdmModel model, ActionLinkBuilder builder,
ODataMetadataLevel metadataLevel)
{
Contract.Assert(model != null);
Contract.Assert(builder != null);
switch (metadataLevel)
{
case ODataMetadataLevel.MinimalMetadata:
case ODataMetadataLevel.NoMetadata:
return model.IsAlwaysBindable(action) && builder.FollowsConventions;
case ODataMetadataLevel.Default:
case ODataMetadataLevel.FullMetadata:
default: // All values already specified; just keeping the compiler happy.
return false;
}
}
public void TestShouldOmitAction(TestODataMetadataLevel metadataLevel, bool isAlwaysAvailable,
bool followsConventions, bool expectedResult)
{
// Arrange
IEdmFunctionImport action = CreateFakeFunctionImport(true);
IEdmDirectValueAnnotationsManager annonationsManager = CreateFakeAnnotationsManager();
if (isAlwaysAvailable)
{
annonationsManager.SetIsAlwaysBindable(action);
}
IEdmModel model = CreateFakeModel(annonationsManager);
ActionLinkBuilder builder = new ActionLinkBuilder((a) => { throw new NotImplementedException(); },
followsConventions);
// Act
bool actualResult = ODataEntityTypeSerializer.ShouldOmitAction(action, model, builder,
(ODataMetadataLevel)metadataLevel);
// Assert
Assert.Equal(expectedResult, actualResult);
}
