public void GetODataSerializer_ReturnsNull_IfTypeUnknown()
{
// Arrange
HttpRequest request = GetRequest(_edmModel);
// Act
IODataSerializer serializer = _serializerProvider.GetODataPayloadSerializer(typeof(UnknownEntityType), request);
// Assert
Assert.Null(serializer);
}
public void GetEdmTypeSerializer_Caches_CreateEdmTypeSerializerOutput()
{
// Arrange
IEdmTypeReference edmType = new Mock <IEdmTypeReference>().Object;
// Act
IODataSerializer serializer1 = _serializerProvider.GetEdmTypeSerializer(edmType);
IODataSerializer serializer2 = _serializerProvider.GetEdmTypeSerializer(edmType);
// Assert
Assert.Same(serializer2, serializer1);
}
public void GetODataSerializer_Returns_ExpectedSerializerType(Type payloadType, Type expectedSerializerType)
{
// Arrange
HttpRequest request = GetRequest(EdmCoreModel.Instance);
// Act
IODataSerializer serializer = _serializerProvider.GetODataPayloadSerializer(payloadType, request);
// Assert
Assert.NotNull(serializer);
Assert.IsType(expectedSerializerType, serializer);
}
public void GetODataSerializer_ReturnsSameSerializer_ForSameType()
{
// Arrange
HttpRequest request = GetRequest(_edmModel);
// Act
IODataSerializer firstCallSerializer = _serializerProvider.GetODataPayloadSerializer(typeof(Product), request);
IODataSerializer secondCallSerializer = _serializerProvider.GetODataPayloadSerializer(typeof(Product), request);
// Assert
Assert.Same(firstCallSerializer, secondCallSerializer);
}
public void GetODataSerializer_Enum()
{
// Arrange
HttpRequest request = GetRequest(_edmModel);
// Act
IODataSerializer serializer = _serializerProvider.GetODataPayloadSerializer(typeof(TestEnum), request);
// Assert
Assert.NotNull(serializer);
var enumSerializer = Assert.IsType <ODataEnumSerializer>(serializer);
Assert.Equal(ODataPayloadKind.Property, enumSerializer.ODataPayloadKind);
}
public void GetODataSerializer_Primitive(Type type, EdmPrimitiveTypeKind edmPrimitiveTypeKind)
{
// Arrange
HttpRequest request = GetRequest(EdmCoreModel.Instance);
// Act
IODataSerializer serializer = _serializerProvider.GetODataPayloadSerializer(type, request);
// Assert
Assert.NotEqual(EdmPrimitiveTypeKind.None, edmPrimitiveTypeKind);
Assert.NotNull(serializer);
ODataPrimitiveSerializer primitiveSerializer = Assert.IsType <ODataPrimitiveSerializer>(serializer);
Assert.Equal(ODataPayloadKind.Property, primitiveSerializer.ODataPayloadKind);
}
public void GetODataSerializer_ResourceSet_ForComplexCollection(Type collectionType)
{
// Arrange
HttpRequest request = GetRequest(_edmModel);
// Act
IODataSerializer serializer = _serializerProvider.GetODataPayloadSerializer(collectionType, request);
// Assert
Assert.NotNull(serializer);
var resourceSetSerializer = Assert.IsType <ODataResourceSetSerializer>(serializer);
Assert.Equal(ODataPayloadKind.ResourceSet, resourceSetSerializer.ODataPayloadKind);
Assert.Same(resourceSetSerializer.SerializerProvider, _serializerProvider);
}
public void GetODataSerializer_Resource_ForComplex()
{
// Arrange
HttpRequest request = GetRequest(_edmModel);
// Act
IODataSerializer serializer = _serializerProvider.GetODataPayloadSerializer(typeof(Address), request);
// Assert
Assert.NotNull(serializer);
var complexSerializer = Assert.IsType <ODataResourceSerializer>(serializer);
Assert.Equal(complexSerializer.SerializerProvider, _serializerProvider);
Assert.Equal(ODataPayloadKind.Resource, complexSerializer.ODataPayloadKind);
}
public void GetODataSerializer_Resource_ForEntity()
{
// Arrange
HttpRequest request = GetRequest(_edmModel);
// Act
IODataSerializer serializer = _serializerProvider.GetODataPayloadSerializer(typeof(Product), request);
// Assert
Assert.NotNull(serializer);
var entitySerializer = Assert.IsType <ODataResourceSerializer>(serializer);
Assert.Equal(entitySerializer.SerializerProvider, _serializerProvider);
Assert.Equal(ODataPayloadKind.Resource, entitySerializer.ODataPayloadKind);
}
public void GetODataPayloadSerializer_ReturnsRawValueSerializer_ForValueRequests(Type type, EdmPrimitiveTypeKind edmPrimitiveTypeKind)
{
// Arrange
ODataPath odataPath = new ODataPath(new ValueSegment(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Int32)));
HttpRequest request = GetRequest(EdmCoreModel.Instance);
request.ODataFeature().Path = odataPath;
// Act
IODataSerializer serializer = _serializerProvider.GetODataPayloadSerializer(type, request);
// Assert
Assert.NotEqual(EdmPrimitiveTypeKind.None, edmPrimitiveTypeKind);
Assert.NotNull(serializer);
Assert.Equal(ODataPayloadKind.Value, serializer.ODataPayloadKind);
}
public void GetODataPayloadSerializer_ReturnsRawValueSerializer_ForEnumValueRequests()
{
// Arrange
ODataPath odataPath = new ODataPath(new ValueSegment(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Int32)));
HttpRequest request = GetRequest(_edmModel);
request.ODataFeature().Path = odataPath;
// Act
IODataSerializer serializer = _serializerProvider.GetODataPayloadSerializer(typeof(TestEnum), request);
// Assert
Assert.NotNull(serializer);
var rawValueSerializer = Assert.IsType <ODataRawValueSerializer>(serializer);
Assert.Equal(ODataPayloadKind.Value, rawValueSerializer.ODataPayloadKind);
}
internal static async Task WriteToStreamAsync(
Type type,
object value,
IEdmModel model,
ODataVersion version,
Uri baseAddress,
MediaTypeHeaderValue contentType,
HttpRequest request,
IHeaderDictionary requestHeaders,
IODataSerializerProvider serializerProvider)
{
if (model == null)
{
throw Error.InvalidOperation(SRResources.RequestMustHaveModel);
}
IODataSerializer serializer = GetSerializer(type, value, request, serializerProvider);
ODataPath path = request.ODataFeature().Path;
IEdmNavigationSource targetNavigationSource = GetTargetNavigationSource(path, model);
HttpResponse response = request.HttpContext.Response;
// serialize a response
string preferHeader = RequestPreferenceHelpers.GetRequestPreferHeader(requestHeaders);
string annotationFilter = null;
if (!string.IsNullOrEmpty(preferHeader))
{
ODataMessageWrapper messageWrapper = ODataMessageWrapperHelper.Create(response.Body, response.Headers);
messageWrapper.SetHeader(RequestPreferenceHelpers.PreferHeaderName, preferHeader);
annotationFilter = messageWrapper.PreferHeader().AnnotationFilter;
}
IODataResponseMessageAsync responseMessage = ODataMessageWrapperHelper.Create(new StreamWrapper(response.Body), response.Headers, request.GetRouteServices());
if (annotationFilter != null)
{
responseMessage.PreferenceAppliedHeader().AnnotationFilter = annotationFilter;
}
ODataMessageWriterSettings writerSettings = request.GetWriterSettings();
writerSettings.BaseUri = baseAddress;
writerSettings.Version = version;
writerSettings.Validations = writerSettings.Validations & ~ValidationKinds.ThrowOnUndeclaredPropertyForNonOpenType;
string metadataLink = request.CreateODataLink(MetadataSegment.Instance);
if (metadataLink == null)
{
throw new SerializationException(SRResources.UnableToDetermineMetadataUrl);
}
// Set this variable if the SelectExpandClause is different from the processed clause on the Query options
SelectExpandClause selectExpandDifferentFromQueryOptions = null;
ODataQueryOptions queryOptions = request.GetQueryOptions();
SelectExpandClause processedSelectExpandClause = request.ODataFeature().SelectExpandClause;
if (queryOptions != null && queryOptions.SelectExpand != null)
{
if (queryOptions.SelectExpand.ProcessedSelectExpandClause != processedSelectExpandClause)
{
selectExpandDifferentFromQueryOptions = processedSelectExpandClause;
}
}
else if (processedSelectExpandClause != null)
{
selectExpandDifferentFromQueryOptions = processedSelectExpandClause;
}
writerSettings.ODataUri = new ODataUri
{
ServiceRoot = baseAddress,
// TODO: 1604 Convert webapi.odata's ODataPath to ODL's ODataPath, or use ODL's ODataPath.
SelectAndExpand = processedSelectExpandClause,
Apply = request.ODataFeature().ApplyClause,
Path = path
};
ODataMetadataLevel metadataLevel = ODataMetadataLevel.Minimal;
if (contentType != null)
{
IEnumerable <KeyValuePair <string, string> > parameters =
contentType.Parameters.Select(val => new KeyValuePair <string, string>(val.Name.ToString(),
val.Value.ToString()));
metadataLevel = ODataMediaTypes.GetMetadataLevel(contentType.MediaType.ToString(), parameters);
}
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, writerSettings, model))
{
ODataSerializerContext writeContext = BuildSerializerContext(request);
writeContext.NavigationSource = targetNavigationSource;
writeContext.Model = model;
writeContext.RootElementName = GetRootElementName(path) ?? "root";
writeContext.SkipExpensiveAvailabilityChecks = serializer.ODataPayloadKind == ODataPayloadKind.ResourceSet;
writeContext.Path = path;
writeContext.MetadataLevel = metadataLevel;
writeContext.QueryOptions = queryOptions;
writeContext.SetComputedProperties(queryOptions?.Compute?.ComputeClause);
//Set the SelectExpandClause on the context if it was explicitly specified.
if (selectExpandDifferentFromQueryOptions != null)
{
writeContext.SelectExpandClause = selectExpandDifferentFromQueryOptions;
}
await serializer.WriteObjectAsync(value, type, messageWriter, writeContext).ConfigureAwait(false);
}
}
