public async Task PrimitiveTypesSerializeAsOData(Type valueType, object value, string mediaType, string resourceName)
{
// Arrange
string expectedEntity = Resources.GetString(resourceName);
Assert.NotNull(expectedEntity); // Guard
ODataConventionModelBuilder modelBuilder = ODataConventionModelBuilderFactory.Create();
modelBuilder.EntitySet <WorkItem>("WorkItems");
IEdmModel model = modelBuilder.GetEdmModel();
IEdmProperty property = model.EntityContainer.EntitySets().Single().EntityType().Properties().First();
ODataPath path = new ODataPath(new PropertySegment(property as IEdmStructuralProperty));
var configuration = RoutingConfigurationFactory.CreateWithRootContainer("OData");
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/WorkItems(10)/ID", configuration, "OData", path);
var formatter = FormatterTestHelper.GetFormatter(new ODataPayloadKind[] { ODataPayloadKind.Property }, request, mediaType);
// Act
Type type = (value != null) ? value.GetType() : typeof(Nullable <int>);
var content = FormatterTestHelper.GetContent(value, type, formatter, mediaType.ToString());
string actualEntity = await FormatterTestHelper.GetContentResult(content, request);
// Assert
Assert.NotNull(valueType);
JsonAssert.Equal(expectedEntity, actualEntity);
}
public async Task NullPrimitiveValueDeserializeAsOData(Type valueType, object value, string mediaType, string resourceName)
{
// Arrange
string entity = Resources.GetString(resourceName);
Assert.NotNull(entity);
object expectedValue = value;
ODataConventionModelBuilder modelBuilder = ODataConventionModelBuilderFactory.Create();
modelBuilder.EntitySet <WorkItem>("WorkItems");
IEdmModel model = modelBuilder.GetEdmModel();
var configuration = RoutingConfigurationFactory.CreateWithRootContainer("OData", c => c.AddService(ServiceLifetime.Singleton, b => model));
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/WorkItems(10)/ID", configuration, "OData");
var formatter = FormatterTestHelper.GetInputFormatter(new ODataPayloadKind[] { ODataPayloadKind.Property }, request, mediaType);
// Act
object actualValue = await FormatterTestHelper.ReadAsync(formatter, entity, valueType, request, mediaType);
// Assert
Assert.Equal(expectedValue, actualValue);
}
public async Task Queryable_UsesRouteModel_ForMultipleModels()
{
// Model 1 only has Name, Model 2 only has Age
ODataModelBuilder builder1 = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
var personType1 = builder1.EntityType <FormatterPerson>().Property(p => p.Name);
builder1.EntitySet <FormatterPerson>("People").HasIdLink(p => new Uri("http://link/"), false);
var model1 = builder1.GetEdmModel();
ODataModelBuilder builder2 = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
builder2.EntityType <FormatterPerson>().Property(p => p.Age);
builder2.EntitySet <FormatterPerson>("People").HasIdLink(p => new Uri("http://link/"), false);
var model2 = builder2.GetEdmModel();
var config = RoutingConfigurationFactory.CreateWithTypes(new[] { typeof(PeopleController) });
config.MapODataServiceRoute("OData1", "v1", model1);
config.MapODataServiceRoute("OData2", "v2", model2);
using (HttpServer host = new HttpServer(config))
using (HttpClient client = new HttpClient(host))
{
// Model 1 has the Name property but not the Age property
await AssertRespondsWithExpectedStatusCode(client, "http://localhost/v1/People?$orderby=Name", HttpStatusCode.OK);
await AssertRespondsWithExpectedStatusCode(client, "http://localhost/v1/People?$orderby=Age", HttpStatusCode.BadRequest);
// Model 2 has the Age property but not the Name property
await AssertRespondsWithExpectedStatusCode(client, "http://localhost/v2/People?$orderby=Name", HttpStatusCode.BadRequest);
await AssertRespondsWithExpectedStatusCode(client, "http://localhost/v2/People?$orderby=Age", HttpStatusCode.OK);
}
}
public void ODataEntityReferenceLinkSerializer_Serializes_UrisAndEntityReferenceLinks_WithCount(object uris)
{
// Arrange
var config = RoutingConfigurationFactory.CreateWithRootContainer("OData");
var request = RequestFactory.Create(config, "OData");
ODataEntityReferenceLinksSerializer serializer = new ODataEntityReferenceLinksSerializer();
ODataSerializerContext writeContext = new ODataSerializerContext();
writeContext.Request = request;
writeContext.Request.ODataContext().TotalCount = 1;
MemoryStream stream = new MemoryStream();
IODataResponseMessage message = new ODataMessageWrapper(stream);
ODataMessageWriterSettings settings = new ODataMessageWriterSettings
{
ODataUri = new ODataUri {
ServiceRoot = new Uri("http://any/")
}
};
settings.SetContentType(ODataFormat.Json);
ODataMessageWriter writer = new ODataMessageWriter(message, settings);
// Act
serializer.WriteObject(uris, typeof(ODataEntityReferenceLinks), writer, writeContext);
stream.Seek(0, SeekOrigin.Begin);
string result = new StreamReader(stream).ReadToEnd();
Assert.Equal(
string.Format("{0},{1},{2}",
"{\"@odata.context\":\"http://any/$metadata#Collection($ref)\"",
"\"@odata.count\":1",
"\"value\":[{\"@odata.id\":\"http://uri1/\"}]}"), result);
}
public async Task ListOfDatesSerializesAsOData()
{
// Arrange
const string expect =
"{" +
"\"@odata.context\":\"http://localhost/$metadata#Collection(Edm.Date)\",\"value\":[" +
"\"0001-01-01\",\"2015-02-26\",\"9999-12-31\"" +
"]" +
"}";
List <Date> listOfDates = new List <Date>();
listOfDates.Add(Date.MinValue);
listOfDates.Add(new Date(2015, 2, 26));
listOfDates.Add(Date.MaxValue);
var routeName = "OData";
var model = GetSampleModel();
var config = RoutingConfigurationFactory.CreateWithRootContainer(routeName, b => b.AddService(ServiceLifetime.Singleton, s => model));
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/property", config, routeName);
var payload = new ODataPayloadKind[] { ODataPayloadKind.Collection };
var formatter = FormatterTestHelper.GetFormatter(payload, request);
var content = FormatterTestHelper.GetContent(listOfDates, formatter,
ODataMediaTypes.ApplicationJsonODataMinimalMetadata);
// Act & Assert
JsonAssert.Equal(expect, await FormatterTestHelper.GetContentResult(content, request));
}
public async Task SendAsync_ReturnsNotFoundForNullEntityResponse()
{
// Arrange
Mock <MediaTypeFormatter> formatter = new Mock <MediaTypeFormatter>();
formatter.Setup(f => f.CanWriteType(It.IsAny <Type>())).Returns(true);
HttpResponseMessage originalResponse = new HttpResponseMessage(HttpStatusCode.OK);
originalResponse.Content = new ObjectContent(typeof(string), null, formatter.Object);
ODataNullValueMessageHandler handler = new ODataNullValueMessageHandler
{
InnerHandler = new TestMessageHandler(originalResponse)
};
var configuration = RoutingConfigurationFactory.Create();
ODataPath path = new DefaultODataPathHandler().Parse(BuildModel(), "http://localhost/any", "Customers(3)");
HttpRequestMessage request = RequestFactory.Create(HttpMethod.Get, "http://localhost/any", configuration);
request.ODataContext().Path = path;
// Act
HttpResponseMessage response = await handler.SendAsync(request);
// Assert
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
public async Task ExtensionResolver_Works_EnumPrefixFree(string parameter, bool enableEnumPrefix, HttpStatusCode statusCode)
{
// Arrange
IEdmModel model = GetEdmModel();
var config = RoutingConfigurationFactory.CreateWithTypes(new[] { typeof(ParserExtenstionCustomersController) });
ODataUriResolver resolver = new ODataUriResolver();
if (enableEnumPrefix)
{
resolver = new StringAsEnumResolver();
}
config.MapODataServiceRoute("odata", "odata",
builder =>
builder.AddService(ServiceLifetime.Singleton, sp => model)
.AddService <IEnumerable <IODataRoutingConvention> >(ServiceLifetime.Singleton, sp =>
ODataRoutingConventions.CreateDefaultWithAttributeRouting("odata", config))
.AddService(ServiceLifetime.Singleton, sp => resolver));
HttpClient client = new HttpClient(new HttpServer(config));
// Act
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get,
String.Format("http://localhost/odata/ParserExtenstionCustomers/Default.GetCustomerByGender({0})", parameter));
HttpResponseMessage response = await client.SendAsync(request);
// Assert
Assert.Equal(statusCode, response.StatusCode);
if (statusCode == HttpStatusCode.OK)
{
Assert.Equal("GetCustomerByGender/Male", (response.Content as ObjectContent <string>).Value);
}
}
private static HttpConfiguration GetConfiguration(bool caseInsensitive, bool unqualifiedNameCall)
{
IEdmModel model = ODataRoutingModel.GetModel();
HttpConfiguration config = RoutingConfigurationFactory.CreateWithTypes(new[]
{
typeof(MetadataController),
typeof(ProductsController),
typeof(RoutingCustomersController),
});
ODataUriResolver resolver = new ODataUriResolver();
if (unqualifiedNameCall)
{
resolver = new UnqualifiedODataUriResolver();
}
resolver.EnableCaseInsensitive = caseInsensitive;
config.Count().Filter().OrderBy().Expand().MaxTop(null).Select();
config.MapODataServiceRoute("odata", "odata",
builder =>
builder.AddService(ServiceLifetime.Singleton, sp => model)
.AddService <IEnumerable <IODataRoutingConvention> >(ServiceLifetime.Singleton, sp =>
ODataRoutingConventions.CreateDefaultWithAttributeRouting("odata", config))
.AddService(ServiceLifetime.Singleton, sp => resolver));
return(config);
}
public void CreateODataValue_ReturnsDateTimeOffset_ForDateTime_WithDifferentTimeZone(DateTime value)
{
// Arrange
IEdmPrimitiveTypeReference edmPrimitiveType =
EdmLibHelpers.GetEdmPrimitiveTypeReferenceOrNull(typeof(DateTime));
ODataPrimitiveSerializer serializer = new ODataPrimitiveSerializer();
TimeZoneInfo tzi = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time");
var configuration = RoutingConfigurationFactory.CreateWithRootContainer("OData");
configuration.SetTimeZoneInfo(tzi);
var request = RequestFactory.Create(configuration, "OData");
ODataSerializerContext context = new ODataSerializerContext {
Request = request
};
DateTimeOffset expected = value.Kind == DateTimeKind.Unspecified
? new DateTimeOffset(value, TimeZoneInfoHelper.TimeZone.GetUtcOffset(value))
: TimeZoneInfo.ConvertTime(new DateTimeOffset(value), TimeZoneInfoHelper.TimeZone);
// Act
ODataValue odataValue = serializer.CreateODataValue(value, edmPrimitiveType, context);
// Assert
ODataPrimitiveValue primitiveValue = Assert.IsType <ODataPrimitiveValue>(odataValue);
Assert.Equal(expected, primitiveValue.Value);
}
public void ReadJsonLight()
{
// Arrange
var deserializer = new ODataEntityReferenceLinkDeserializer();
MockODataRequestMessage requestMessage = new MockODataRequestMessage();
ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings();
writerSettings.SetContentType(ODataFormat.Json);
IEdmModel model = CreateModel();
ODataMessageWriter messageWriter = new ODataMessageWriter(requestMessage, writerSettings, model);
messageWriter.WriteEntityReferenceLink(new ODataEntityReferenceLink {
Url = new Uri("http://localhost/samplelink")
});
ODataMessageReader messageReader = new ODataMessageReader(new MockODataRequestMessage(requestMessage),
new ODataMessageReaderSettings(), model);
IEdmNavigationProperty navigationProperty = GetNavigationProperty(model);
var config = RoutingConfigurationFactory.CreateWithRootContainer("OData");
var request = RequestFactory.Create(config, "OData");
ODataDeserializerContext context = new ODataDeserializerContext
{
Request = request,
Path = new ODataPath(new NavigationPropertySegment(navigationProperty, navigationSource: null))
};
// Act
Uri uri = deserializer.Read(messageReader, typeof(Uri), context) as Uri;
// Assert
Assert.NotNull(uri);
Assert.Equal("http://localhost/samplelink", uri.AbsoluteUri);
}
public void NavigationLinksGenerationConvention_GeneratesLinksWithCast_ForDerivedProperties()
{
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create();
builder.EntitySet <Vehicle>("vehicles");
builder.EntitySet <Manufacturer>("manufacturers");
IEdmModel model = builder.GetEdmModel();
IEdmEntitySet vehiclesEdmEntitySet = model.EntityContainer.FindEntitySet("vehicles");
IEdmEntityType carType = model.AssertHasEntityType(typeof(Car));
IEdmNavigationProperty carManufacturerProperty = carType.AssertHasNavigationProperty(model, "Manufacturer", typeof(CarManufacturer), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne);
var configuration = RoutingConfigurationFactory.Create();
string routeName = "Route";
configuration.MapODataServiceRoute(routeName, null, model);
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost", configuration, routeName);
NavigationSourceLinkBuilderAnnotation linkBuilder = model.GetNavigationSourceLinkBuilder(vehiclesEdmEntitySet);
linkBuilder.AddNavigationPropertyLinkBuilder(carManufacturerProperty, new NavigationLinkBuilder((context, property) => context.GenerateNavigationPropertyLink(property, includeCast: true), false));
var serializerContext = ODataSerializerContextFactory.Create(model, vehiclesEdmEntitySet, request);
var entityContext = new ResourceContext(serializerContext, carType.AsReference(), new Car {
Model = 2009, Name = "Accord"
});
Uri uri = linkBuilder.BuildNavigationLink(entityContext, carManufacturerProperty, ODataMetadataLevel.MinimalMetadata);
Assert.Equal("http://localhost/vehicles(Model=2009,Name='Accord')/Microsoft.AspNet.OData.Test.Builder.TestModels.Car/Manufacturer", uri.AbsoluteUri);
}
public async Task ExtensionResolver_Works_EnumPrefixFree_QueryOption(string query, bool enableEnumPrefix, HttpStatusCode statusCode, string output)
{
// Arrange
IEdmModel model = GetEdmModel();
var config = RoutingConfigurationFactory.CreateWithTypes(new[] { typeof(ParserExtenstionCustomersController) });
ODataUriResolver resolver = new ODataUriResolver();
if (enableEnumPrefix)
{
resolver = new StringAsEnumResolver();
}
config.MapODataServiceRoute("odata", "odata",
builder =>
builder.AddService(ServiceLifetime.Singleton, sp => model)
.AddService <IEnumerable <IODataRoutingConvention> >(ServiceLifetime.Singleton, sp =>
ODataRoutingConventions.CreateDefaultWithAttributeRouting("odata", config))
.AddService(ServiceLifetime.Singleton, sp => resolver));
HttpClient client = new HttpClient(new HttpServer(config));
// Act
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get,
String.Format("http://localhost/odata/ParserExtenstionCustomers?{0}", query));
HttpResponseMessage response = await client.SendAsync(request);
// Assert
Assert.Equal(statusCode, response.StatusCode);
if (statusCode == HttpStatusCode.OK)
{
JObject content = await response.Content.ReadAsAsync <JObject>();
Assert.Equal(output, String.Join(",", content["value"].Select(e => e["Id"])));
}
}
public void Convention_GeneratesUri_ForActionBoundToEntity()
{
// Arrange
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create();
builder.EntitySet <Customer>("Customers");
var action = builder.EntityType <Customer>().Action("MyAction");
action.Parameter <string>("param");
IEdmModel model = builder.GetEdmModel();
// Act
var configuration = RoutingConfigurationFactory.Create();
configuration.MapODataServiceRoute("odata", "odata", model);
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost:123", configuration, "odata");
IEdmEntitySet customers = model.EntityContainer.FindEntitySet("Customers");
var edmType = model.SchemaElements.OfType <IEdmEntityType>().First(e => e.Name == "Customer");
var serializerContext = ODataSerializerContextFactory.Create(model, customers, request);
var resourceContext = new ResourceContext(serializerContext, edmType.AsReference(), new Customer {
Id = 109
});
// Assert
var edmAction = model.SchemaElements.OfType <IEdmAction>().First(f => f.Name == "MyAction");
Assert.NotNull(edmAction);
OperationLinkBuilder actionLinkBuilder = model.GetOperationLinkBuilder(edmAction);
Uri link = actionLinkBuilder.BuildLink(resourceContext);
Assert.Equal("http://localhost:123/odata/Customers(109)/Default.MyAction", link.AbsoluteUri);
}
public void CreateResourceSet_SetsODataOperations()
{
// Arrange
var config = RoutingConfigurationFactory.CreateWithRootContainer("OData");
var request = RequestFactory.Create(config, "OData");
CustomersModelWithInheritance model = new CustomersModelWithInheritance();
IEdmCollectionTypeReference customersType = new EdmCollectionTypeReference(new EdmCollectionType(model.Customer.AsReference()));
ODataResourceSetSerializer serializer = new ODataResourceSetSerializer(_serializerProvider);
ODataSerializerContext context = new ODataSerializerContext
{
NavigationSource = model.Customers,
Request = request,
Model = model.Model,
MetadataLevel = ODataMetadataLevel.FullMetadata,
Url = CreateMetadataLinkFactory("http://IgnoreMetadataPath", request)
};
var result = new object[0];
// Act
ODataResourceSet resourceSet = serializer.CreateResourceSet(result, customersType, context);
// Assert
Assert.Single(resourceSet.Actions);
Assert.Equal(3, resourceSet.Functions.Count());
}
public void CtorTakingHttpConfiguration_InitializesAttributeMappings_OnFirstSelectControllerCall()
{
// Arrange
var config = RoutingConfigurationFactory.CreateWithRootContainer(RouteName);
var serviceProvider = GetServiceProvider(config, RouteName);
var request = RequestFactory.Create(config, RouteName);
#if NETCORE
request.ODataFeature().Path = new ODataPath();
request.Method = "Get";
ControllerDescriptorFactory.Create(config, "MetadataAndService", typeof(MetadataAndServiceController));
#endif
ODataPathTemplate pathTemplate = new ODataPathTemplate();
Mock <IODataPathTemplateHandler> pathTemplateHandler = new Mock <IODataPathTemplateHandler>();
pathTemplateHandler.Setup(p => p.ParseTemplate("$metadata", serviceProvider))
.Returns(pathTemplate).Verifiable();
AttributeRoutingConvention convention = CreateAttributeRoutingConvention(RouteName, config, pathTemplateHandler.Object);
EnsureAttributeMapping(convention, config);
// Act
Select(convention, request);
// Assert
pathTemplateHandler.VerifyAll();
Assert.NotNull(convention.AttributeMappings);
Assert.Equal("GetMetadata", convention.AttributeMappings[pathTemplate].ActionName);
}
public void ODataVersionConstraint_DefaultValue()
{
var config = RoutingConfigurationFactory.Create();
ODataRoute odataRoute = CreateRoute(config, routePrefix: null);
Assert.True(((ODataVersionConstraint)odataRoute.Constraints[ODataRouteConstants.VersionConstraintName]).IsRelaxedMatch);
}
public async Task BadReturnTypeThrows(string methodName)
{
// Arrange
ODataQueryParameterBindingAttribute attribute = new ODataQueryParameterBindingAttribute();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/Customer/?$orderby=Name");
var config = RoutingConfigurationFactory.Create();
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
request.SetConfiguration(config);
HttpControllerContext controllerContext = new HttpControllerContext(config, new HttpRouteData(new HttpRoute()), request);
HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(new HttpConfiguration(), "CustomerLowLevel", typeof(CustomerHighLevelController));
MethodInfo methodInfo = typeof(CustomerLowLevelController).GetMethod(methodName);
ParameterInfo parameterInfo = methodInfo.GetParameters().First();
HttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, methodInfo);
HttpActionContext actionContext = new HttpActionContext(controllerContext, actionDescriptor);
HttpParameterDescriptor parameterDescriptor = new ReflectedHttpParameterDescriptor(actionDescriptor, parameterInfo);
// Act
HttpParameterBinding binding = attribute.GetBinding(parameterDescriptor);
// Act & Assert
await ExceptionAssert.ThrowsAsync <InvalidOperationException>(
() => binding.ExecuteBindingAsync((ModelMetadataProvider)null, actionContext, CancellationToken.None),
String.Format(
"Cannot create an EDM model as the action '{0}' on controller '{1}' has a return type '{2}' that does not implement IEnumerable<T>.",
actionDescriptor.ActionName,
actionDescriptor.ControllerDescriptor.ControllerName,
actionDescriptor.ReturnType.FullName));
}
public void WhenActionLinksNotManuallyConfigured_ConventionBasedBuilderUsesConventions()
{
// Arrange
string uriTemplate = "http://server/Movies({0})/Default.Watch";
Uri expectedUri = new Uri(string.Format(uriTemplate, 1));
ODataModelBuilder builder = ODataConventionModelBuilderFactory.Create();
EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType;
ActionConfiguration watch = movie.Action("Watch");
IEdmModel model = builder.GetEdmModel();
var configuration = RoutingConfigurationFactory.Create();
string routeName = "Route";
configuration.MapODataServiceRoute(routeName, null, model);
var request = RequestFactory.Create(HttpMethod.Get, "http://server/Movies", configuration, routeName);
// Act
IEdmEntityType movieType = model.SchemaElements.OfType <IEdmEntityType>().SingleOrDefault();
IEdmEntityContainer container = model.SchemaElements.OfType <IEdmEntityContainer>().SingleOrDefault();
IEdmAction watchAction = Assert.Single(model.SchemaElements.OfType <IEdmAction>()); // Guard
IEdmEntitySet entitySet = container.EntitySets().SingleOrDefault();
ODataSerializerContext serializerContext = ODataSerializerContextFactory.Create(model, entitySet, request);
ResourceContext context = new ResourceContext(serializerContext, movieType.AsReference(), new Movie {
ID = 1, Name = "Avatar"
});
OperationLinkBuilder actionLinkBuilder = model.GetAnnotationValue <OperationLinkBuilder>(watchAction);
//Assert
Assert.Equal(expectedUri, watch.GetActionLink()(context));
Assert.NotNull(actionLinkBuilder);
Assert.Equal(expectedUri, actionLinkBuilder.BuildLink(context));
}
public void AttributeMappingsIsInitialized_WithRightActionAndTemplate(Type controllerType,
string expectedPathTemplate, string expectedActionName)
{
// Arrange
var configuration = RoutingConfigurationFactory.CreateWithRootContainer(RouteName);
var serviceProvider = GetServiceProvider(configuration, RouteName);
var request = RequestFactory.Create(configuration, RouteName);
var descriptors = ControllerDescriptorFactory.Create(configuration, "TestController",
controllerType);
ODataPathTemplate pathTemplate = new ODataPathTemplate();
Mock <IODataPathTemplateHandler> pathTemplateHandler = new Mock <IODataPathTemplateHandler>();
pathTemplateHandler
.Setup(p => p.ParseTemplate(expectedPathTemplate, serviceProvider))
.Returns(pathTemplate)
.Verifiable();
AttributeRoutingConvention convention = new AttributeRoutingConvention(RouteName, descriptors, pathTemplateHandler.Object);
// Act
Select(convention, request);
// Assert
pathTemplateHandler.VerifyAll();
Assert.NotNull(convention.AttributeMappings);
Assert.Equal(expectedActionName, convention.AttributeMappings[pathTemplate].ActionName);
}
public void Convention_GeneratesUri_ForActionBoundToCollectionOfEntity()
{
// Arrange
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create();
builder.EntitySet <Customer>("Customers");
var action = builder.EntityType <Customer>().Collection.Action("MyAction").Returns <int>();
action.Parameter <string>("param");
IEdmModel model = builder.GetEdmModel();
// Act
var configuration = RoutingConfigurationFactory.Create();
configuration.MapODataServiceRoute("odata", "odata", model);
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost:123", configuration, "odata");
IEdmEntitySet customers = model.EntityContainer.FindEntitySet("Customers");
var entityContext = ResourceSetContextFactory.Create(customers, request);
// Assert
var edmAction = model.SchemaElements.OfType <IEdmAction>().First(f => f.Name == "MyAction");
Assert.NotNull(edmAction);
OperationLinkBuilder actionLinkBuilder = model.GetOperationLinkBuilder(edmAction);
Uri link = actionLinkBuilder.BuildLink(entityContext);
Assert.Equal("http://localhost:123/odata/Customers/Default.MyAction", link.AbsoluteUri);
}
public async Task ListOfDateTimeSerializesAsOData_CustomTimeZone()
{
// Arrange
const string expect =
"{" +
"\"@odata.context\":\"http://localhost/$metadata#Collection(Edm.DateTimeOffset)\",\"value\":[" +
"\"1978-11-14T17:12:13-08:00\",\"2014-10-27T04:25:26-08:00\"" +
"]" +
"}";
List <DateTime> listOfDateTime = new List <DateTime>();
listOfDateTime.Add(new DateTime(1978, 11, 15, 01, 12, 13, DateTimeKind.Utc));
listOfDateTime.Add(new DateTime(2014, 10, 27, 12, 25, 26, DateTimeKind.Utc));
var routeName = "OData";
var model = GetSampleModel();
var config = RoutingConfigurationFactory.CreateWithRootContainer(routeName, b => b.AddService(ServiceLifetime.Singleton, s => model));
config.SetTimeZoneInfo(TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time"));
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/property", config, routeName);
var payload = new ODataPayloadKind[] { ODataPayloadKind.Collection };
var formatter = FormatterTestHelper.GetFormatter(payload, request);
var content = FormatterTestHelper.GetContent(listOfDateTime, formatter,
ODataMediaTypes.ApplicationJsonODataMinimalMetadata);
// Act & Assert
JsonAssert.Equal(expect, await FormatterTestHelper.GetContentResult(content, request));
}
public async Task ListOfNullableDateTimeSerializesAsOData()
{
// Arrange
DateTime dt1 = new DateTime(1978, 11, 15, 01, 12, 13, DateTimeKind.Local);
DateTime dt2 = new DateTime(2014, 10, 27, 12, 25, 26, DateTimeKind.Local);
List <DateTime?> listOfDateTime = new List <DateTime?> {
dt1, null, dt2
};
var routeName = "OData";
var model = GetSampleModel();
var config = RoutingConfigurationFactory.CreateWithRootContainer(routeName, b => b.AddService(ServiceLifetime.Singleton, s => model));
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/property", config, routeName);
var payload = new ODataPayloadKind[] { ODataPayloadKind.Collection };
var formatter = FormatterTestHelper.GetFormatter(payload, request);
var content = FormatterTestHelper.GetContent(listOfDateTime, formatter,
ODataMediaTypes.ApplicationJsonODataMinimalMetadata);
// Act & Assert
dynamic result = JObject.Parse(await FormatterTestHelper.GetContentResult(content, request));
Assert.Equal(3, result["value"].Count);
DateTimeOffset?dto = (DateTimeOffset?)result["value"][0];
Assert.Equal(new DateTimeOffset(dt1), dto.Value);
dto = (DateTimeOffset?)result["value"][1];
Assert.Null(dto);
dto = (DateTimeOffset?)result["value"][2];
Assert.Equal(new DateTimeOffset(dt2), dto.Value);
}
public async Task ListOfNullableTimeOfDaysSerializesAsOData()
{
// Arrange
const string expect =
"{" +
"\"@odata.context\":\"http://localhost/$metadata#Collection(Edm.TimeOfDay)\",\"value\":[" +
"\"00:00:00.0000000\",\"01:02:03.0040000\",null,\"23:59:59.9999999\"" +
"]" +
"}";
List <TimeOfDay?> listOfDates = new List <TimeOfDay?>();
listOfDates.Add(TimeOfDay.MinValue);
listOfDates.Add(new TimeOfDay(1, 2, 3, 4));
listOfDates.Add(null);
listOfDates.Add(TimeOfDay.MaxValue);
var routeName = "OData";
var model = GetSampleModel();
var config = RoutingConfigurationFactory.CreateWithRootContainer(routeName, b => b.AddService(ServiceLifetime.Singleton, s => model));
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/property", config, routeName);
var payload = new ODataPayloadKind[] { ODataPayloadKind.Collection };
var formatter = FormatterTestHelper.GetFormatter(payload, request);
var content = FormatterTestHelper.GetContent(listOfDates, formatter,
ODataMediaTypes.ApplicationJsonODataMinimalMetadata);
// Act & Assert
JsonAssert.Equal(expect, await FormatterTestHelper.GetContentResult(content, request));
}
public void WhenFeedActionLinksNotManuallyConfigured_ConventionBasedBuilderUsesConventions()
{
// Arrange
Uri expectedUri = new Uri("http://server/Movies/Default.Watch(param=@param)");
ODataModelBuilder builder = ODataConventionModelBuilderFactory.Create();
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();
var configuration = RoutingConfigurationFactory.Create();
string routeName = "Route";
configuration.MapODataServiceRoute(routeName, null, model);
var request = RequestFactory.Create(HttpMethod.Get, "http://server/Movies", configuration, routeName);
// Act
IEdmEntityContainer container = model.SchemaElements.OfType <IEdmEntityContainer>().SingleOrDefault();
IEdmFunction watchFunction = Assert.Single(model.SchemaElements.OfType <IEdmFunction>()); // Guard
IEdmEntitySet entitySet = container.EntitySets().SingleOrDefault();
ODataSerializerContextFactory.Create(model, entitySet, request);
ResourceSetContext context = ResourceSetContextFactory.Create(entitySet, request);
OperationLinkBuilder functionLinkBuilder = model.GetAnnotationValue <OperationLinkBuilder>(watchFunction);
//Assert
Assert.Equal(expectedUri, watch.GetFeedFunctionLink()(context));
Assert.NotNull(functionLinkBuilder);
Assert.Equal(expectedUri, functionLinkBuilder.BuildLink(context));
}
public void CtorTakingModelAndConfiguration_ThrowsArgumentNull_RouteName()
{
var configuration = RoutingConfigurationFactory.Create();
ExceptionAssert.ThrowsArgumentNull(
() => CreateAttributeRoutingConvention(null, configuration),
"routeName");
}
public MockHttpServer(Func <HttpRequestMessage, HttpResponseMessage> action)
: base(RoutingConfigurationFactory.CreateWithRootContainer("OData"))
{
_action = request =>
{
return(Task.FromResult(action(request)));
};
}
private static ODataConventionModelBuilder GetProductsBuilder()
{
var configuration = RoutingConfigurationFactory.CreateWithTypes(typeof(Product));
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create(configuration);
builder.EntitySet <Product>("Product");
return(builder);
}
private static IEdmModel GetCustomersModel()
{
var configuration = RoutingConfigurationFactory.CreateWithTypes(typeof(QueryCompositionCustomer));
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create(configuration);
builder.EntitySet <QueryCompositionCustomer>("Customer");
builder.EntityType <QueryCompositionCustomerBase>();
return(builder.GetEdmModel());
}
public void CtorTakingModelAndConfigurationAndPathHandler_ThrowsArgumentNull_PathTemplateHandler()
{
var configuration = RoutingConfigurationFactory.CreateWithRootContainer("OData");
ExceptionAssert.ThrowsArgumentNull(
() => new AttributeRoutingConvention(configuration: configuration,
routeName: RouteName, pathTemplateHandler: null),
"pathTemplateHandler");
}
public void CanGenerateDirectLink_IsFalse_IfRouteTemplateHasParameterInPrefix()
{
// Arrange && Act
var config = RoutingConfigurationFactory.Create();
ODataRoute odataRoute = CreateRoute(config, "{prefix}");
// Assert
Assert.False(odataRoute.CanGenerateDirectLink);
}
