public void CreateCollectionWriterWithTypeDefinitionAsItemType()
{
var writer = new ODataMessageWriter(new DummyRequestMessage());
var entityElementType = new EdmTypeDefinitionReference(new EdmTypeDefinition("NS", "Test", EdmPrimitiveTypeKind.Int32), false);
var collectionWriter = writer.CreateODataCollectionWriter(entityElementType);
Assert.IsNotNull(collectionWriter, "CreateODataCollectionWriter with type definition item type failed.");
}
public void CreateMessageWriterShouldSetAnnotationFilterWhenODataAnnotationIsSetOnPreferenceAppliedHeader()
{
IODataResponseMessage responseMessage = new InMemoryMessage();
responseMessage.PreferenceAppliedHeader().AnnotationFilter = "*";
ODataMessageWriter writer = new ODataMessageWriter(responseMessage, new ODataMessageWriterSettings());
writer.Settings.ShouldIncludeAnnotation.Should().NotBeNull();
}
public void CreateCollectionWriterWithEnumAsItemType()
{
var writer = new ODataMessageWriter(new DummyRequestMessage());
var entityElementType = new EdmEnumTypeReference(new EdmEnumType("FakeNS", "FakeEnum"), true);
var collectionWriter = writer.CreateODataCollectionWriter(entityElementType);
Assert.IsNotNull(collectionWriter, "CreateODataCollectionWriter with enum item type failed.");
}
public void CreateCollectionWriterWithEntityCollectionTypeShouldFail()
{
var writer = new ODataMessageWriter(new DummyRequestMessage());
var entityElementType = new EdmEntityTypeReference(new EdmEntityType("Fake", "Fake"), true);
Action createWriterWithEntityCollectionType = () => writer.CreateODataCollectionWriter(entityElementType);
createWriterWithEntityCollectionType.ShouldThrow<ODataException>().WithMessage(Strings.ODataMessageWriter_NonCollectionType("Fake.Fake"));
}
public void CreateCollectionWriterWithoutTypeShouldPassForJsonLight()
{
var settings = new ODataMessageWriterSettings();
settings.SetContentType(ODataFormat.Json);
var writer = new ODataMessageWriter(new DummyRequestMessage(), settings, new EdmModel());
writer.CreateODataCollectionWriter(null).Should().BeOfType<ODataJsonLightCollectionWriter>();
}
/// <summary>Initializes a new NonEntitySerializer instance.</summary>
/// <param name="requestDescription">Description of request.</param>
/// <param name="absoluteServiceUri">Base URI from which resources should be resolved.</param>
/// <param name="service">Service with configuration and provider from which metadata should be gathered.</param>
/// <param name="messageWriter">ODataMessageWriter instance which needs to be used to write the response.</param>
internal NonEntitySerializer(RequestDescription requestDescription, Uri absoluteServiceUri, IDataService service, ODataMessageWriter messageWriter)
: base(requestDescription, absoluteServiceUri, service, null)
{
Debug.Assert(messageWriter != null, "messageWriter != null");
this.writer = messageWriter;
}
public void WriteObject_WritesValueReturnedFrom_CreateODataCollectionValue()
{
// Arrange
MemoryStream stream = new MemoryStream();
IODataResponseMessage message = new ODataMessageWrapper(stream);
ODataMessageWriter messageWriter = new ODataMessageWriter(message);
Mock<ODataCollectionSerializer> serializer = new Mock<ODataCollectionSerializer>(new DefaultODataSerializerProvider());
ODataSerializerContext writeContext = new ODataSerializerContext { RootElementName = "CollectionName", Model = _model };
IEnumerable enumerable = new object[0];
ODataCollectionValue collectionValue = new ODataCollectionValue { TypeName = "NS.Name", Items = new[] { 0, 1, 2 } };
serializer.CallBase = true;
serializer
.Setup(s => s.CreateODataCollectionValue(enumerable, It.Is<IEdmTypeReference>(e => e.Definition == _edmIntType.Definition), writeContext))
.Returns(collectionValue).Verifiable();
// Act
serializer.Object.WriteObject(enumerable, typeof(int[]), messageWriter, writeContext);
// Assert
serializer.Verify();
stream.Seek(0, SeekOrigin.Begin);
XElement element = XElement.Load(stream);
Assert.Equal("CollectionName", element.Name.LocalName);
Assert.Equal(3, element.Descendants().Count());
Assert.Equal(new[] { "0", "1", "2" }, element.Descendants().Select(e => e.Value));
}
public void OrderFeedTest()
{
foreach (var mimeType in this.mimeTypes)
{
var settings = new ODataMessageWriterSettings();
settings.ODataUri = new ODataUri() { ServiceRoot = this.ServiceUri };
string outputWithModel = null;
string outputWithoutModel = null;
var responseMessageWithModel = new StreamResponseMessage(new MemoryStream());
responseMessageWithModel.SetHeader("Content-Type", mimeType);
using (var messageWriter = new ODataMessageWriter(responseMessageWithModel, settings, WritePayloadHelper.Model))
{
var odataWriter = messageWriter.CreateODataFeedWriter(WritePayloadHelper.OrderSet, WritePayloadHelper.OrderType);
outputWithModel = this.WriteAndVerifyOrderFeed(responseMessageWithModel, odataWriter, true, mimeType);
}
var responseMessageWithoutModel = new StreamResponseMessage(new MemoryStream());
responseMessageWithoutModel.SetHeader("Content-Type", mimeType);
using (var messageWriter = new ODataMessageWriter(responseMessageWithoutModel, settings))
{
var odataWriter = messageWriter.CreateODataFeedWriter();
outputWithoutModel = this.WriteAndVerifyOrderFeed(responseMessageWithoutModel, odataWriter, false,
mimeType);
}
WritePayloadHelper.VerifyPayloadString(outputWithModel, outputWithoutModel, mimeType);
}
}
/// <summary>
/// Determines the response format based on the results of content negotiation.
/// </summary>
/// <param name="payloadKind">The payload kind of the response.</param>
/// <param name="acceptableMediaTypes">
/// The acceptable media types used to determine the content type of the message.
/// This is a comma separated list of content types as specified in RFC 2616, Section 14.1
/// </param>
/// <param name="acceptableCharSets">
/// The acceptable charsets to use to the determine the encoding of the message.
/// This is a comma separated list of charsets as specified in RFC 2616, Section 14.2
/// </param>
/// <returns>The format the response should use. </returns>
internal ODataFormatWithParameters DetermineResponseFormat(ODataPayloadKind payloadKind, string acceptableMediaTypes, string acceptableCharSets)
{
Debug.Assert(payloadKind != ODataPayloadKind.Unsupported, "kind != ODataPayloadKind.Unsupported");
ContentNegotiationResponseMessage responseMessage = new ContentNegotiationResponseMessage();
ODataMessageWriterSettings settings = new ODataMessageWriterSettings { Version = this.responseVersion };
settings.EnableAtomSupport();
settings.SetContentType(acceptableMediaTypes, acceptableCharSets);
try
{
using (ODataMessageWriter writer = new ODataMessageWriter(responseMessage, settings))
{
ODataFormat format = ODataUtils.SetHeadersForPayload(writer, payloadKind);
return new ODataFormatWithParameters(format, responseMessage.ContentType);
}
}
catch (ODataContentTypeException exception)
{
if (this.throwIfNoMatch)
{
throw new DataServiceException(415, null, Microsoft.OData.Service.Strings.DataServiceException_UnsupportedMediaType, null, exception);
}
return null;
}
}
/// <inheritdoc />
public override void WriteObject(object graph, Type type, ODataMessageWriter messageWriter,
ODataSerializerContext writeContext)
{
if (messageWriter == null)
{
throw Error.ArgumentNull("messageWriter");
}
if (writeContext == null)
{
throw Error.ArgumentNull("writeContext");
}
IEdmNavigationSource navigationSource = writeContext.NavigationSource;
if (navigationSource == null)
{
throw new SerializationException(SRResources.NavigationSourceMissingDuringSerialization);
}
var path = writeContext.Path;
if (path == null)
{
throw new SerializationException(SRResources.ODataPathMissing);
}
ODataWriter writer = messageWriter.CreateODataEntryWriter(navigationSource, path.EdmType as IEdmEntityType);
WriteObjectInline(graph, navigationSource.EntityType().ToEdmTypeReference(isNullable: false), writer, writeContext);
}
/// <inheritdoc/>
public override void WriteObject(object graph, Type type, ODataMessageWriter messageWriter, ODataSerializerContext writeContext)
{
if (graph == null)
{
throw Error.ArgumentNull("graph");
}
if (messageWriter == null)
{
throw Error.ArgumentNull("messageWriter");
}
ODataError oDataError = graph as ODataError;
if (oDataError == null)
{
HttpError httpError = graph as HttpError;
if (httpError == null)
{
string message = Error.Format(SRResources.ErrorTypeMustBeODataErrorOrHttpError, graph.GetType().FullName);
throw new SerializationException(message);
}
else
{
oDataError = httpError.CreateODataError();
}
}
bool includeDebugInformation = oDataError.InnerError != null;
messageWriter.WriteError(oDataError, includeDebugInformation);
}
public void WriteCompletedAsyncResponse()
{
var asyncWriter = this.TestInit();
var innerMessage = asyncWriter.CreateResponseMessage();
innerMessage.StatusCode = 200;
innerMessage.SetHeader("Content-Type", "application/json");
var settings = new ODataMessageWriterSettings();
settings.SetServiceDocumentUri(new Uri(ServiceDocumentUri));
settings.DisableMessageStreamDisposal = true;
using (var innerMessageWriter = new ODataMessageWriter(innerMessage, settings, this.userModel))
{
var entryWriter = innerMessageWriter.CreateODataEntryWriter(singleton, testType);
var entry = new ODataEntry() {TypeName = "NS.Test", Properties = new[] {new ODataProperty() {Name = "Id", Value = 1}}};
entryWriter.WriteStart(entry);
entryWriter.WriteEnd();
}
asyncWriter.Flush();
var payload = this.TestFinish();
Assert.Equal("HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nOData-Version: 4.0\r\n\r\n{\"@odata.context\":\"http://host/service/$metadata#MySingleton\",\"Id\":1}", payload);
}
/// <inheritdoc/>
public override void WriteObject(object graph, ODataMessageWriter messageWriter, ODataSerializerContext writeContext)
{
if (messageWriter == null)
{
throw Error.ArgumentNull("messageWriter");
}
if (writeContext == null)
{
throw Error.ArgumentNull("writeContext");
}
ODataCollectionWriter writer = messageWriter.CreateODataCollectionWriter();
writer.WriteStart(
new ODataCollectionStart
{
Name = writeContext.RootElementName
});
ODataProperty property = CreateProperty(graph, writeContext.RootElementName, writeContext);
if (property != null)
{
ODataCollectionValue collectionValue = property.Value as ODataCollectionValue;
foreach (object item in collectionValue.Items)
{
writer.WriteItem(item);
}
writer.WriteEnd();
writer.Flush();
}
}
public override void WriteObject(object graph, ODataMessageWriter messageWriter, ODataSerializerContext writeContext)
{
if (messageWriter == null)
{
throw Error.ArgumentNull("messageWriter");
}
if (writeContext == null)
{
throw Error.ArgumentNull("writeContext");
}
IEdmEntitySet entitySet = writeContext.EntitySet;
if (entitySet == null)
{
throw new SerializationException(SRResources.EntitySetMissingDuringSerialization);
}
// No null check; entity type is not required for successful serialization.
IEdmEntityType entityType = _edmElementType;
ODataWriter writer = messageWriter.CreateODataFeedWriter(entitySet, entityType);
WriteObjectInline(graph, writer, writeContext);
writer.Flush();
}
public void WriteMessageAsync_ResponseContainsContentId_IfHasContentIdInRequestChangeSet()
{
MemoryStream ms = new MemoryStream();
HttpContent content = new StringContent(String.Empty, Encoding.UTF8, "multipart/mixed");
content.Headers.ContentType.Parameters.Add(new NameValueHeaderValue("boundary", Guid.NewGuid().ToString()));
IODataResponseMessage odataResponse = new ODataMessageWrapper(ms, content.Headers);
var batchWriter = new ODataMessageWriter(odataResponse).CreateODataBatchWriter();
HttpResponseMessage response = new HttpResponseMessage
{
Content = new StringContent("any", Encoding.UTF8, "text/example")
};
var request = new HttpRequestMessage();
var contentId = Guid.NewGuid().ToString();
request.SetODataContentId(contentId);
response.RequestMessage = request;
batchWriter.WriteStartBatch();
batchWriter.WriteStartChangeset();
ODataBatchResponseItem.WriteMessageAsync(batchWriter, response, CancellationToken.None).Wait();
batchWriter.WriteEndChangeset();
batchWriter.WriteEndBatch();
ms.Position = 0;
string result = new StreamReader(ms).ReadToEnd();
Assert.Contains("any", result);
Assert.Contains("text/example", result);
Assert.Contains("Content-ID", result);
Assert.Contains(contentId, result);
}
public void EntryMetadataUrlRoundTrip()
{
var stream = new MemoryStream();
var writerRequestMemoryMessage = new InMemoryMessage();
writerRequestMemoryMessage.Stream = stream;
writerRequestMemoryMessage.SetHeader("Content-Type", "application/json");
var writerSettings = new ODataMessageWriterSettings() {Version = ODataVersion.V4, DisableMessageStreamDisposal = true};
writerSettings.ODataUri = new ODataUri() {ServiceRoot = new Uri("http://christro.svc/")};
var messageWriter = new ODataMessageWriter((IODataResponseMessage)writerRequestMemoryMessage, writerSettings, this.model);
var organizationSetWriter = messageWriter.CreateODataEntryWriter(this.organizationsSet);
var odataEntry = new ODataEntry(){ TypeName = ModelNamespace + ".Corporation" };
odataEntry.Property("Id", 1);
odataEntry.Property("Name", "");
odataEntry.Property("TickerSymbol", "MSFT");
organizationSetWriter.WriteStart(odataEntry);
organizationSetWriter.WriteEnd();
var readerPayloadInput = Encoding.UTF8.GetString(stream.GetBuffer());
Console.WriteLine(readerPayloadInput);
var readerResponseMemoryMessage = new InMemoryMessage();
readerResponseMemoryMessage.Stream = new MemoryStream(stream.GetBuffer());
readerResponseMemoryMessage.SetHeader("Content-Type", "application/json");
var messageReader = new ODataMessageReader((IODataResponseMessage)readerResponseMemoryMessage, new ODataMessageReaderSettings() {MaxProtocolVersion = ODataVersion.V4, DisableMessageStreamDisposal = true}, this.model);
var organizationReader = messageReader.CreateODataEntryReader(this.organizationsSet, this.organizationsSet.EntityType());
organizationReader.Read().Should().Be(true);
organizationReader.Item.As<ODataEntry>();
}
public void WriteObject_WritesValueReturnedFrom_CreateODataCollectionValue()
{
// Arrange
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 messageWriter = new ODataMessageWriter(message, settings);
Mock<ODataCollectionSerializer> serializer = new Mock<ODataCollectionSerializer>(new DefaultODataSerializerProvider());
ODataSerializerContext writeContext = new ODataSerializerContext { RootElementName = "CollectionName", Model = _model };
IEnumerable enumerable = new object[0];
ODataCollectionValue collectionValue = new ODataCollectionValue { TypeName = "NS.Name", Items = new[] { 0, 1, 2 } };
serializer.CallBase = true;
serializer
.Setup(s => s.CreateODataCollectionValue(enumerable, It.Is<IEdmTypeReference>(e => e.Definition == _edmIntType.Definition), writeContext))
.Returns(collectionValue).Verifiable();
// Act
serializer.Object.WriteObject(enumerable, typeof(int[]), messageWriter, writeContext);
// Assert
serializer.Verify();
stream.Seek(0, SeekOrigin.Begin);
string result = new StreamReader(stream).ReadToEnd();
Assert.Equal("{\"@odata.context\":\"http://any/$metadata#Collection(Edm.Int32)\",\"value\":[0,1,2]}", result);
}
/// <inheritdoc />
public override void WriteObject(object graph, Type type, ODataMessageWriter messageWriter, ODataSerializerContext writeContext)
{
if (messageWriter == null)
{
throw Error.ArgumentNull("messageWriter");
}
if (writeContext == null)
{
throw Error.ArgumentNull("writeContext");
}
IEdmEntitySetBase entitySet = writeContext.NavigationSource as IEdmEntitySetBase;
if (entitySet == null)
{
throw new SerializationException(SRResources.EntitySetMissingDuringSerialization);
}
IEdmTypeReference feedType = writeContext.GetEdmType(graph, type);
Contract.Assert(feedType != null);
IEdmEntityTypeReference entityType = GetEntityType(feedType);
ODataWriter writer = messageWriter.CreateODataFeedWriter(entitySet, entityType.EntityDefinition());
WriteObjectInline(graph, feedType, writer, writeContext);
}
public void WriteMessageAsync_WritesResponseMessage()
{
MemoryStream ms = new MemoryStream();
HttpContent content = new StringContent(String.Empty, Encoding.UTF8, "multipart/mixed");
content.Headers.ContentType.Parameters.Add(new NameValueHeaderValue("boundary", Guid.NewGuid().ToString()));
IODataResponseMessage odataResponse = new ODataMessageWrapper(ms, content.Headers);
var batchWriter = new ODataMessageWriter(odataResponse).CreateODataBatchWriter();
HttpResponseMessage response = new HttpResponseMessage()
{
Content = new StringContent("example content", Encoding.UTF8, "text/example")
};
response.Headers.Add("customHeader", "bar");
batchWriter.WriteStartBatch();
ODataBatchResponseItem.WriteMessageAsync(batchWriter, response).Wait();
batchWriter.WriteEndBatch();
ms.Position = 0;
string result = new StreamReader(ms).ReadToEnd();
Assert.Contains("example content", result);
Assert.Contains("text/example", result);
Assert.Contains("customHeader", result);
Assert.Contains("bar", result);
}
public override void WriteObject(object graph, ODataMessageWriter messageWriter, ODataSerializerContext writeContext)
{
if (messageWriter == null)
{
throw Error.ArgumentNull("messageWriter");
}
if (writeContext == null)
{
throw Error.ArgumentNull("writeContext");
}
IEdmEntitySet entitySet = writeContext.EntitySet;
if (entitySet == null)
{
throw new SerializationException(SRResources.EntitySetMissingDuringSerialization);
}
IEdmNavigationProperty navigationProperty = GetNavigationProperty(writeContext.Path);
if (navigationProperty == null)
{
throw new SerializationException(SRResources.NavigationPropertyMissingDuringSerialization);
}
messageWriter.WriteEntityReferenceLink(new ODataEntityReferenceLink { Url = graph as Uri }, entitySet,
navigationProperty);
}
/// <inheridoc />
public override void WriteObject(object graph, Type type, ODataMessageWriter messageWriter, ODataSerializerContext writeContext)
{
if (messageWriter == null)
{
throw Error.ArgumentNull("messageWriter");
}
if (writeContext == null)
{
throw Error.ArgumentNull("writeContext");
}
if (graph != null)
{
ODataEntityReferenceLinks entityReferenceLinks = graph as ODataEntityReferenceLinks;
if (entityReferenceLinks == null)
{
IEnumerable<Uri> uris = graph as IEnumerable<Uri>;
if (uris == null)
{
throw new SerializationException(Error.Format(SRResources.CannotWriteType, GetType().Name, graph.GetType().FullName));
}
entityReferenceLinks = new ODataEntityReferenceLinks
{
Links = uris.Select(uri => new ODataEntityReferenceLink { Url = uri })
};
}
messageWriter.WriteEntityReferenceLinks(entityReferenceLinks);
}
}
/// <inheritdoc/>
public override Task WriteObjectAsync(object graph, Type type, ODataMessageWriter messageWriter, ODataSerializerContext writeContext)
{
if (messageWriter == null)
{
throw Error.ArgumentNull("messageWriter");
}
if (writeContext == null)
{
throw Error.ArgumentNull("writeContext");
}
if (graph != null)
{
ODataEntityReferenceLink entityReferenceLink = graph as ODataEntityReferenceLink;
if (entityReferenceLink == null)
{
Uri uri = graph as Uri;
if (uri == null)
{
throw new SerializationException(Error.Format(SRResources.CannotWriteType, GetType().Name, graph.GetType().FullName));
}
entityReferenceLink = new ODataEntityReferenceLink { Url = uri };
}
messageWriter.WriteEntityReferenceLink(entityReferenceLink);
}
return Task.FromResult(true);
}
/// <summary>
/// Writes the entity result to the response message.
/// </summary>
/// <param name="graph">The entity result to write.</param>
/// <param name="type">The type of the entity.</param>
/// <param name="messageWriter">The message writer.</param>
/// <param name="writeContext">The writing context.</param>
public override void WriteObject(
object graph,
Type type,
ODataMessageWriter messageWriter,
ODataSerializerContext writeContext)
{
RawResult rawResult = graph as RawResult;
if (rawResult != null)
{
graph = rawResult.Result;
type = rawResult.Type;
}
if (writeContext != null)
{
graph = RestierPrimitiveSerializer.ConvertToPayloadValue(graph, writeContext);
}
if (graph == null)
{
// This is to make ODataRawValueSerializer happily serialize null value.
graph = string.Empty;
}
base.WriteObject(graph, type, messageWriter, writeContext);
}
public override void WriteObject(object graph, Type type, ODataMessageWriter messageWriter, ODataSerializerContext writeContext)
{
if (messageWriter == null)
{
throw new ArgumentNullException("messageWriter");
}
if (writeContext == null)
{
throw new ArgumentNullException("writeContext");
}
if (graph != null)
{
Uri[] uris = graph as Uri[];
if (uris == null)
{
throw new SerializationException("Cannot write the type");
}
messageWriter.WriteEntityReferenceLinks(new ODataEntityReferenceLinks
{
Links = uris.Select(uri => new ODataEntityReferenceLink { Url = uri })
});
}
}
public void WriteObject_ThrowsSerializationException_WhenEntitySetIsMissingInWriteContext()
{
ODataMessageWriter messageWriter = new ODataMessageWriter(new Mock<IODataRequestMessage>().Object);
Assert.Throws<SerializationException>(
() => _serializer.WriteObject(graph: _customer, type: typeof(Customer), messageWriter: messageWriter, writeContext: new ODataSerializerContext()),
"The related entity set could not be found from the OData path. The related entity set is required to serialize the payload.");
}
public override void WriteObject(object graph, ODataMessageWriter messageWriter, ODataSerializerContext writeContext)
{
if (messageWriter == null)
{
throw Error.ArgumentNull("messageWriter");
}
if (writeContext == null)
{
throw Error.ArgumentNull("writeContext");
}
if (graph == null)
{
throw new SerializationException(Error.Format(Properties.SRResources.CannotSerializerNull,
ODataFormatterConstants.Entry));
}
IEdmEntitySet entitySet = writeContext.EntitySet;
if (entitySet == null)
{
throw new SerializationException(SRResources.EntitySetMissingDuringSerialization);
}
// No null check; entity type is not required for successful serialization.
IEdmEntityType entityType = _edmEntityTypeReference.Definition as IEdmEntityType;
ODataWriter writer = messageWriter.CreateODataEntryWriter(entitySet, entityType);
WriteObjectInline(graph, writer, writeContext);
writer.Flush();
}
public void WriteObject_Calls_CreateODataComplexValue()
{
// Arrange
MemoryStream stream = new MemoryStream();
IODataResponseMessage message = new ODataMessageWrapper(stream);
ODataMessageWriterSettings settings = new ODataMessageWriterSettings();
settings.SetServiceDocumentUri(new Uri("http://any/"));
settings.SetContentType(ODataFormat.Atom);
ODataMessageWriter messageWriter = new ODataMessageWriter(message, settings);
Mock<ODataComplexTypeSerializer> serializer = new Mock<ODataComplexTypeSerializer>(new DefaultODataSerializerProvider());
ODataSerializerContext writeContext = new ODataSerializerContext { RootElementName = "ComplexPropertyName", Model = _model };
object graph = new object();
ODataComplexValue complexValue = new ODataComplexValue
{
TypeName = "NS.Name",
Properties = new[] { new ODataProperty { Name = "Property1", Value = 42 } }
};
serializer.CallBase = true;
serializer.Setup(s => s.CreateODataComplexValue(graph, It.Is<IEdmComplexTypeReference>(e => e.Definition == _addressType), writeContext))
.Returns(complexValue).Verifiable();
// Act
serializer.Object.WriteObject(graph, typeof(Address), messageWriter, writeContext);
// Assert
serializer.Verify();
stream.Seek(0, SeekOrigin.Begin);
XElement element = XElement.Load(stream);
Assert.Equal("value", element.Name.LocalName);
Assert.Equal("#NS.Name", element.Attributes().Single(a => a.Name.LocalName == "type").Value);
Assert.Equal(1, element.Descendants().Count());
Assert.Equal("42", element.Descendants().Single().Value);
Assert.Equal("Property1", element.Descendants().Single().Name.LocalName);
}
public void WriteObject_ThrowsArgumentNull_WriteContext()
{
ODataMessageWriter messageWriter = new ODataMessageWriter(new Mock<IODataRequestMessage>().Object);
Assert.ThrowsArgumentNull(
() => _serializer.WriteObject(graph: new object(), messageWriter: messageWriter, writeContext: null),
"writeContext");
}
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);
ODataDeserializerContext context = new ODataDeserializerContext
{
Request = new HttpRequestMessage(),
Path = new ODataPath(new NavigationPathSegment(navigationProperty))
};
// Act
Uri uri = deserializer.Read(messageReader, typeof(Uri), context) as Uri;
// Assert
Assert.NotNull(uri);
Assert.Equal("http://localhost/samplelink", uri.AbsoluteUri);
}
/// <inheritdoc/>
public override void WriteObject(object graph, ODataMessageWriter messageWriter, ODataSerializerContext writeContext)
{
if (messageWriter == null)
{
throw Error.ArgumentNull("messageWriter");
}
if (writeContext == null)
{
throw Error.ArgumentNull("writeContext");
}
ODataCollectionWriter writer = messageWriter.CreateODataCollectionWriter(_edmItemType);
writer.WriteStart(
new ODataCollectionStart
{
Name = writeContext.RootElementName
});
ODataValue value = CreateODataValue(graph, writeContext);
if (value != null)
{
ODataCollectionValue collectionValue = value as ODataCollectionValue;
Contract.Assert(value != null);
foreach (object item in collectionValue.Items)
{
writer.WriteItem(item);
}
}
writer.WriteEnd();
writer.Flush();
}
/// <inheritdoc/>
public override Task WriteObjectAsync(object graph, Type type, ODataMessageWriter messageWriter, ODataSerializerContext writeContext)
{
if (messageWriter == null)
{
throw Error.ArgumentNull("messageWriter");
}
if (graph == null)
{
throw Error.ArgumentNull("graph");
}
ODataServiceDocument serviceDocument = graph as ODataServiceDocument;
if (serviceDocument == null)
{
throw new SerializationException(Error.Format(SRResources.CannotWriteType, GetType().Name, type.Name));
}
messageWriter.WriteServiceDocument(serviceDocument);
return(Task.FromResult(false));
}
public async Task SerializesEnumType()
{
// Arrange
ODataRawValueSerializer serializer = new ODataRawValueSerializer();
Mock <IODataRequestMessageAsync> mockRequest = new Mock <IODataRequestMessageAsync>();
Stream stream = new MemoryStream();
mockRequest.Setup(r => r.GetStreamAsync()).ReturnsAsync(stream);
ODataMessageWriter messageWriter = new ODataMessageWriter(mockRequest.Object);
object value = Color.Red | Color.Blue;
// Act
await serializer.WriteObjectAsync(value, value.GetType(), messageWriter, null);
stream.Seek(0, SeekOrigin.Begin);
TextReader reader = new StreamReader(stream);
string result = await reader.ReadToEndAsync();
// Assert
Assert.Equal(value.ToString(), result, ignoreCase: true);
}
public void EntityContainer_Is_Default_DoesNotShowUp_In_Metadata()
{
// Arrange
EdmModel model = new EdmModel();
EdmEntityContainer container = new EdmEntityContainer("Default", "SampleContainer");
model.AddElement(container);
// Act & Assert
MemoryStream stream = new MemoryStream();
ODataMessageWriter writer = new ODataMessageWriter(new ODataMessageWrapper(stream) as IODataResponseMessage, new ODataMessageWriterSettings(), model);
writer.WriteMetadataDocument();
stream.Seek(0, SeekOrigin.Begin);
XElement element = XElement.Load(stream);
var containerXml = element.Descendants().SingleOrDefault(n => n.Name.LocalName == "EntityContainer");
Assert.NotNull(containerXml);
Assert.Equal("SampleContainer", containerXml.Attribute("Name").Value);
Assert.Null(containerXml.Attributes().FirstOrDefault(a => a.Name.LocalName == "IsDefaultEntityContainer"));
}
/// <summary>
/// Writes the entity collection results to the response message asynchronously.
/// </summary>
/// <param name="graph">The entity collection results.</param>
/// <param name="type">The type of the entities.</param>
/// <param name="messageWriter">The message writer.</param>
/// <param name="writeContext">The writing context.</param>
/// <returns>A task representing the asynchronous operation.</returns>
public override async Task WriteObjectAsync(object graph, Type type, ODataMessageWriter messageWriter, ODataSerializerContext writeContext)
{
Ensure.NotNull(messageWriter, nameof(messageWriter));
Ensure.NotNull(writeContext, nameof(writeContext));
if (graph is ResourceSetResult collectionResult)
{
graph = collectionResult.Query;
type = collectionResult.Type;
#pragma warning disable CA1062 // Validate public arguments
if (TryWriteAggregationResult(graph, type, messageWriter, writeContext, collectionResult.EdmType))
#pragma warning restore CA1062 // Validate public arguments
{
return;
}
}
await base.WriteObjectAsync(graph, type, messageWriter, writeContext).ConfigureAwait(false);
}
public string GetSampleFeedPayload(IEnumerable entities, IEnumerable <string> projectedProperties)
{
var message = new SimpleResponseMessage(this.StatusCode, this.ContentType);
using (var writer = new ODataMessageWriter(message, Settings))
{
var feedWriter = writer.CreateODataResourceSetWriter();
feedWriter.WriteStart(new ODataResourceSet()
{
Id = new Uri("http://temp.org/feed"), SerializationInfo = MySerializationInfo
});
foreach (var entity in entities)
{
WriteEntry(feedWriter, entity, projectedProperties);
}
feedWriter.WriteEnd();
}
return(message.GetMessageString());
}
/// <inheritdoc/>
public override Task WriteObjectAsync(object graph, Type type, ODataMessageWriter messageWriter, ODataSerializerContext writeContext)
{
if (messageWriter == null)
{
throw Error.ArgumentNull("messageWriter");
}
if (graph == null)
{
throw Error.ArgumentNull("graph");
}
if (graph.GetType().GetTypeInfo().IsEnum)
{
messageWriter.WriteValue(graph.ToString());
}
else
{
messageWriter.WriteValue(ODataPrimitiveSerializer.ConvertUnsupportedPrimitives(graph));
}
return(Task.FromResult(true));
}
public void WriteObject_EdmPrimitives(object graph)
{
IEdmPrimitiveTypeReference edmPrimitiveType = EdmLibHelpers.GetEdmPrimitiveTypeReferenceOrNull(typeof(int));
var serializer = new ODataPrimitiveSerializer();
ODataSerializerContext writecontext = new ODataSerializerContext()
{
RootElementName = "PropertyName", Model = EdmCoreModel.Instance
};
ODataMessageWriterSettings settings = new ODataMessageWriterSettings
{
ODataUri = new ODataUri {
ServiceRoot = new Uri("http://any/"),
}
};
ODataMessageWriter writer = new ODataMessageWriter(
new ODataMessageWrapper(new MemoryStream()) as IODataResponseMessage,
settings);
Assert.DoesNotThrow(() => serializer.WriteObject(graph, typeof(int), writer, writecontext));
}
/// <summary>
/// Writes the entity result to the response message.
/// </summary>
/// <param name="graph">The entity result to write.</param>
/// <param name="type">The type of the entity.</param>
/// <param name="messageWriter">The message writer.</param>
/// <param name="writeContext">The writing context.</param>
public override void WriteObject(
object graph,
Type type,
ODataMessageWriter messageWriter,
ODataSerializerContext writeContext)
{
PrimitiveResult primitiveResult = graph as PrimitiveResult;
if (primitiveResult != null)
{
graph = primitiveResult.Result;
type = primitiveResult.Type;
}
if (writeContext != null)
{
graph = ConvertToPayloadValue(graph, writeContext);
}
base.WriteObject(graph, type, messageWriter, writeContext);
}
/// <inheritdoc/>
public override async Task WriteObjectAsync(object graph, Type type, ODataMessageWriter messageWriter, ODataSerializerContext writeContext)
{
if (graph == null)
{
throw Error.ArgumentNull(nameof(graph));
}
if (messageWriter == null)
{
throw Error.ArgumentNull(nameof(messageWriter));
}
ODataServiceDocument serviceDocument = graph as ODataServiceDocument;
if (serviceDocument == null)
{
throw new SerializationException(Error.Format(SRResources.CannotWriteType, GetType().Name, type?.Name));
}
await messageWriter.WriteServiceDocumentAsync(serviceDocument).ConfigureAwait(false);
}
/// <inheritdoc/>
public override void WriteObject(object graph, Type type, ODataMessageWriter messageWriter, ODataSerializerContext writeContext)
{
if (messageWriter == null)
{
throw Error.ArgumentNull("messageWriter");
}
if (writeContext == null)
{
throw Error.ArgumentNull("writeContext");
}
if (writeContext.RootElementName == null)
{
throw Error.Argument("writeContext", SRResources.RootElementNameMissing, typeof(ODataSerializerContext).Name);
}
IEdmTypeReference edmType = writeContext.GetEdmType(graph, type);
Contract.Assert(edmType != null);
messageWriter.WriteProperty(CreateProperty(graph, edmType, writeContext.RootElementName, writeContext));
}
/// <inheritdoc/>
public override void WriteObject(object graph, ODataMessageWriter messageWriter, ODataSerializerContext writeContext)
{
if (messageWriter == null)
{
throw Error.ArgumentNull("messageWriter");
}
if (graph == null)
{
throw Error.ArgumentNull("graph");
}
ODataWorkspace workspace = graph as ODataWorkspace;
if (workspace == null)
{
throw new SerializationException(Error.Format(SRResources.CannotWriteType, GetType().Name, graph.GetType().Name));
}
messageWriter.WriteServiceDocument(workspace);
}
public static Stream CreatePackagesStream(string baseUrl, IInternalPackageRepository packageRepository, string baseAddress, IEnumerable <IInternalPackage> packages, int feedId, int total)
{
var writerSettings = new ODataMessageWriterSettings()
{
Indent = true,
CheckCharacters = false,
BaseUri = new Uri(baseUrl),
Version = ODataVersion.V3
};
writerSettings.SetContentType(ODataFormat.Atom);
var responseMessage = new MemoryResponseMessage();
var writer = new ODataMessageWriter(responseMessage, writerSettings);
var feedWriter = writer.CreateODataFeedWriter();
feedWriter.WriteStart(new ODataFeed()
{
Id = "Packages", Count = total
});
var pks = packages.Select(pk => new ODataPackage(pk));
foreach (var package in pks)
{
feedWriter.WriteStart(MapPackageToEntry(baseAddress, package));
feedWriter.WriteEnd();
}
feedWriter.WriteEnd();
feedWriter.Flush();
var stream = responseMessage.GetStream();
stream.Seek(0, SeekOrigin.Begin);
return(stream);
}
/// <inheridoc />
public override Task WriteObjectAsync(object graph, Type type, ODataMessageWriter messageWriter, ODataSerializerContext writeContext)
{
if (messageWriter == null)
{
throw Error.ArgumentNull("messageWriter");
}
if (writeContext == null)
{
throw Error.ArgumentNull("writeContext");
}
if (graph != null)
{
ODataEntityReferenceLinks entityReferenceLinks = graph as ODataEntityReferenceLinks;
if (entityReferenceLinks == null)
{
IEnumerable <Uri> uris = graph as IEnumerable <Uri>;
if (uris == null)
{
throw new SerializationException(Error.Format(SRResources.CannotWriteType, GetType().Name, graph.GetType().FullName));
}
entityReferenceLinks = new ODataEntityReferenceLinks
{
Links = uris.Select(uri => new ODataEntityReferenceLink {
Url = uri
})
};
if (writeContext.Request != null)
{
entityReferenceLinks.Count = writeContext.Context.ODataFeature().TotalCount;
}
}
messageWriter.WriteEntityReferenceLinks(entityReferenceLinks);
}
return(Task.FromResult(false));
}
public void WriteObject_WritesValueReturnedFrom_CreateODataCollectionValue()
{
// Arrange
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 messageWriter = new ODataMessageWriter(message, settings);
ODataSerializerProvider provider = new Mock <ODataSerializerProvider>().Object;
Mock <ODataCollectionSerializer> serializer = new Mock <ODataCollectionSerializer>(provider);
ODataSerializerContext writeContext = new ODataSerializerContext {
RootElementName = "CollectionName", Model = EdmCoreModel.Instance
};
IEnumerable enumerable = new int[0];
ODataCollectionValue collectionValue = new ODataCollectionValue {
TypeName = "NS.Name", Items = new object[] { 0, 1, 2 }
};
serializer.CallBase = true;
serializer
.Setup(s => s.CreateODataCollectionValue(enumerable, It.Is <IEdmTypeReference>(e => e.Definition == this._edmIntType.Definition), writeContext))
.Returns(collectionValue).Verifiable();
// Act
serializer.Object.WriteObject(enumerable, typeof(int[]), messageWriter, writeContext);
// Assert
serializer.Verify();
stream.Seek(0, SeekOrigin.Begin);
string result = new StreamReader(stream).ReadToEnd();
Assert.Equal("{\"@odata.context\":\"http://any/$metadata#Collection(Edm.Int32)\",\"value\":[0,1,2]}", result);
}
/// <summary>
/// Writes an entity reference link.
/// </summary>
/// <param name="binding">The link descriptor.</param>
/// <param name="requestMessage">The request message used for writing the payload.</param>
internal void WriteEntityReferenceLink(LinkDescriptor binding, ODataRequestMessageWrapper requestMessage)
#endif
{
using (ODataMessageWriter messageWriter = Serializer.CreateMessageWriter(requestMessage, this.requestInfo, false /*isParameterPayload*/))
{
EntityDescriptor targetResource = this.requestInfo.EntityTracker.GetEntityDescriptor(binding.Target);
Uri targetReferenceLink = targetResource.GetLatestIdentity();
if (targetReferenceLink == null)
{
#if DEBUG
Debug.Assert(isBatch, "we should be cross-referencing entities only in batch scenarios");
#endif
targetReferenceLink = UriUtil.CreateUri("$" + targetResource.ChangeOrder.ToString(CultureInfo.InvariantCulture), UriKind.Relative);
}
ODataEntityReferenceLink referenceLink = new ODataEntityReferenceLink();
referenceLink.Url = targetReferenceLink;
messageWriter.WriteEntityReferenceLink(referenceLink);
}
}
/// <inheritdoc/>
public override void WriteObject(object graph, Type type, ODataMessageWriter messageWriter,
ODataSerializerContext writeContext)
{
if (messageWriter == null)
{
throw Error.ArgumentNull("messageWriter");
}
if (writeContext == null)
{
throw Error.ArgumentNull("writeContext");
}
IEdmTypeReference collectionType = writeContext.GetEdmType(graph, type);
Contract.Assert(collectionType != null);
IEdmTypeReference elementType = GetElementType(collectionType);
ODataCollectionWriter writer = messageWriter.CreateODataCollectionWriter(elementType);
WriteCollection(writer, graph, collectionType.AsCollection(), writeContext);
}
protected void WriteAnnotationsAndValidatePayload(Action <ODataWriter> action, ODataFormat format, string expectedPayload, bool request, bool createFeedWriter)
{
var writerSettings = new ODataMessageWriterSettings {
EnableMessageStreamDisposal = false
};
writerSettings.SetContentType(format);
writerSettings.SetServiceDocumentUri(new Uri("http://www.example.com/"));
MemoryStream stream = new MemoryStream();
if (request)
{
IODataRequestMessage requestMessageToWrite = new InMemoryMessage {
Method = "GET", Stream = stream
};
using (var messageWriter = new ODataMessageWriter(requestMessageToWrite, writerSettings, Model))
{
ODataWriter odataWriter = createFeedWriter ? messageWriter.CreateODataResourceSetWriter(EntitySet, EntityType) : messageWriter.CreateODataResourceWriter(EntitySet, EntityType);
action(odataWriter);
}
}
else
{
IODataResponseMessage responseMessageToWrite = new InMemoryMessage {
StatusCode = 200, Stream = stream
};
using (var messageWriter = new ODataMessageWriter(responseMessageToWrite, writerSettings, Model))
{
ODataWriter odataWriter = createFeedWriter ? messageWriter.CreateODataResourceSetWriter(EntitySet, EntityType) : messageWriter.CreateODataResourceWriter(EntitySet, EntityType);
action(odataWriter);
}
}
stream.Position = 0;
string payload = (new StreamReader(stream)).ReadToEnd();
Assert.Equal(expectedPayload, payload);
}
internal void WriteEntry(EntityDescriptor entityDescriptor, IEnumerable <LinkDescriptor> relatedLinks, ODataRequestMessageWrapper requestMessage)
{
ClientEdmModel model = ClientEdmModel.GetModel(this.requestInfo.MaxProtocolVersion);
ClientTypeAnnotation clientTypeAnnotation = model.GetClientTypeAnnotation(model.GetOrCreateEdmType(entityDescriptor.Entity.GetType()));
using (ODataMessageWriter writer = CreateMessageWriter(requestMessage, this.requestInfo))
{
ODataWriter odataWriter = writer.CreateODataEntryWriter();
ODataEntry entry = new ODataEntry();
if (this.requestInfo.HasWritingEventHandlers)
{
entry.SetAnnotation <WritingEntityInfo>(new WritingEntityInfo(entityDescriptor.Entity, this.requestInfo));
}
string serverTypeName = this.requestInfo.GetServerTypeName(entityDescriptor);
if (clientTypeAnnotation.ElementTypeName != serverTypeName)
{
SerializationTypeNameAnnotation annotation = new SerializationTypeNameAnnotation {
TypeName = serverTypeName
};
entry.SetAnnotation <SerializationTypeNameAnnotation>(annotation);
}
entry.TypeName = clientTypeAnnotation.ElementTypeName;
if (EntityStates.Modified == entityDescriptor.State)
{
entry.Id = entityDescriptor.GetLatestIdentity();
}
if (entityDescriptor.IsMediaLinkEntry || clientTypeAnnotation.IsMediaLinkEntry)
{
entry.MediaResource = new ODataStreamReferenceValue();
}
odataWriter.WriteStart(entry);
if (EntityStates.Added == entityDescriptor.State)
{
this.WriteNavigationLink(entityDescriptor, relatedLinks, odataWriter);
}
entry.Properties = this.PopulateProperties(clientTypeAnnotation, entityDescriptor.Entity, null);
odataWriter.WriteEnd();
}
}
public void WriteResponseAsync_SynchronouslyWritesOperation_Throws()
{
// Arrange
HttpContext context = HttpContextHelper.Create(StatusCodes.Status202Accepted);
OperationResponseItem responseItem = new OperationResponseItem(context);
MemoryStream memoryStream = new MemoryStream();
IODataResponseMessage responseMessage = new ODataMessageWrapper(memoryStream);
ODataMessageWriter writer = new ODataMessageWriter(responseMessage);
// Act
ODataBatchWriter batchWriter = writer.CreateODataBatchWriter();
batchWriter.WriteStartBatch();
// Assert
Action test = () => responseItem.WriteResponseAsync(batchWriter).Wait();
ODataException exception = ExceptionAssert.Throws <ODataException>(test);
Assert.Equal("An asynchronous operation was called on a synchronous batch writer. Calls on a batch writer instance must be either all synchronous or all asynchronous.",
exception.Message);
}
protected override async Task <Stream> WriteLinkContentAsync(string method, string commandText, string linkIdent)
{
IODataRequestMessageAsync message = IsBatch
? await CreateBatchOperationMessageAsync(method, null, null, commandText, false).ConfigureAwait(false)
: new ODataRequestMessage();
using (var messageWriter = new ODataMessageWriter(message, GetWriterSettings(), _model))
{
var link = new ODataEntityReferenceLink
{
Url = Utils.CreateAbsoluteUri(_session.Settings.BaseUri.AbsoluteUri, linkIdent)
};
messageWriter.WriteEntityReferenceLink(link);
if (IsBatch)
{
return(null);
}
return(await message.GetStreamAsync().ConfigureAwait(false));
}
}
public void BatchJsonLightAtomicGroupCannotCreateGroupIdWithNullValue()
{
MemoryStream stream = new MemoryStream();
IODataRequestMessage requestMessage = new InMemoryMessage {
Stream = stream
};
requestMessage.SetHeader("Content-Type", batchContentTypeApplicationJson);
ODataMessageWriterSettings settings = new ODataMessageWriterSettings();
settings.BaseUri = new Uri(serviceDocumentUri);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(requestMessage, settings))
{
ODataBatchWriter batchWriter = messageWriter.CreateODataBatchWriter();
batchWriter.WriteStartBatch();
ArgumentNullException ane = Assert.Throws <ArgumentNullException>(() => batchWriter.WriteStartChangeset(null));
Assert.True(ane.Message.Contains("changesetId"));
}
}
public static async Task SerializeAsync(OeQueryContext queryContext, Db.OeAsyncEnumerator asyncEnumerator, String contentType, Stream stream)
{
OeEntryFactory entryFactory = queryContext.EntryFactory;
var settings = new ODataMessageWriterSettings()
{
BaseUri = queryContext.ODataUri.ServiceRoot,
EnableMessageStreamDisposal = false,
ODataUri = queryContext.ODataUri,
Validations = ValidationKinds.ThrowIfTypeConflictsWithMetadata | ValidationKinds.ThrowOnDuplicatePropertyNames,
Version = ODataVersion.V4
};
IODataResponseMessage responseMessage = new OeInMemoryMessage(stream, contentType);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, settings, queryContext.EdmModel))
{
ODataUtils.SetHeadersForPayload(messageWriter, ODataPayloadKind.ResourceSet);
ODataWriter writer = messageWriter.CreateODataResourceSetWriter(entryFactory.EntitySet, entryFactory.EntityType);
var getWriter = new GetWriter(queryContext, writer);
await getWriter.SerializeAsync(entryFactory, asyncEnumerator, queryContext).ConfigureAwait(false);
}
}
private string WriteAndVerifyLinks(StreamResponseMessage responseMessage, ODataMessageWriter messageWriter, string mimeType)
{
var links = new ODataEntityReferenceLinks()
{
Links = new[]
{
new ODataEntityReferenceLink()
{
Url = new Uri(this.ServiceUri + "Order(-10)")
},
new ODataEntityReferenceLink()
{
Url = new Uri(this.ServiceUri + "Order(-7)")
},
},
NextPageLink = new Uri(this.ServiceUri + "Customer(-10)/Orders/$ref?$skiptoken=-7")
};
messageWriter.WriteEntityReferenceLinks(links);
Stream stream = responseMessage.GetStream();
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
stream.Seek(0, SeekOrigin.Begin);
var settings = new ODataMessageReaderSettings()
{
BaseUri = this.ServiceUri
};
ODataMessageReader messageReader = new ODataMessageReader(responseMessage, settings, WritePayloadHelper.Model);
ODataEntityReferenceLinks linksRead = messageReader.ReadEntityReferenceLinks();
Assert.AreEqual(2, linksRead.Links.Count(), "linksRead.Links.Count");
Assert.IsNotNull(linksRead.NextPageLink, "linksRead.NextPageLink");
}
return(WritePayloadHelper.ReadStreamContent(stream));
}
private bool TryWriteAggregationResult(
object graph,
Type type,
ODataMessageWriter messageWriter,
ODataSerializerContext writeContext,
IEdmTypeReference resourceSetType)
{
if (typeof(IEnumerable <DynamicTypeWrapper>).IsAssignableFrom(type))
{
IEdmTypeReference elementType = resourceSetType.AsCollection().ElementType();
if (elementType.IsEntity())
{
var entitySet = writeContext.NavigationSource as IEdmEntitySetBase;
var entityType = elementType.AsEntity();
var writer = messageWriter.CreateODataResourceSetWriter(entitySet, entityType.EntityDefinition());
WriteObjectInline(graph, resourceSetType, writer, writeContext);
return(true);
}
}
return(false);
}
public void ODataErrorSerializer_Works()
{
// Arrange
ODataErrorSerializer serializer = new ODataErrorSerializer();
MemoryStream stream = new MemoryStream();
IODataResponseMessage message = new ODataMessageWrapper(stream);
ODataError error = new ODataError {
Message = "Error!!!"
};
ODataMessageWriterSettings settings = new ODataMessageWriterSettings();
settings.SetContentType(ODataFormat.Json);
ODataMessageWriter writer = new ODataMessageWriter(message, settings);
// Act
serializer.WriteObject(error, typeof(ODataError), writer, new ODataSerializerContext());
stream.Seek(0, SeekOrigin.Begin);
string result = new StreamReader(stream).ReadToEnd();
// Assert
Assert.Equal("{\"error\":{\"code\":\"\",\"message\":\"Error!!!\"}}", result);
}
public async Task WriteObjectAsync_ThrowsArgumentNull_ForInputParameters()
{
// Arrange
ODataSerializerProvider provider = new Mock <ODataSerializerProvider>().Object;
ODataEnumSerializer serializer = new ODataEnumSerializer(provider);
// Act & Assert
await ExceptionAssert.ThrowsArgumentNullAsync(() => serializer.WriteObjectAsync(graph: null, type: null, messageWriter: null, writeContext: null),
"messageWriter");
// Arrange & Act & Assert
ODataMessageWriter messageWriter = ODataTestUtil.GetMockODataMessageWriter();
await ExceptionAssert.ThrowsArgumentNullAsync(() => serializer.WriteObjectAsync(graph: null, type: null, messageWriter, null),
"writeContext");
// Arrange & Act & Assert
ODataSerializerContext context = new ODataSerializerContext();
context.RootElementName = null;
await ExceptionAssert.ThrowsAsync <ArgumentException>(() => serializer.WriteObjectAsync(graph: null, type: null, messageWriter, context),
"The 'RootElementName' property is required on 'ODataSerializerContext'. (Parameter 'writeContext')");
}
public async Task ReadAsync_Primitive(object obj, string edmType, string value)
{
// Arrange
IEdmModel model = CreateModel();
ODataPrimitiveSerializer serializer = new ODataPrimitiveSerializer();
ODataPrimitiveDeserializer deserializer = new ODataPrimitiveDeserializer();
MemoryStream stream = new MemoryStream();
ODataMessageWrapper message = new ODataMessageWrapper(stream);
ODataMessageWriterSettings settings = new ODataMessageWriterSettings
{
ODataUri = new ODataUri {
ServiceRoot = new Uri("http://any/"),
}
};
settings.SetContentType(ODataFormat.Json);
ODataMessageWriter messageWriter = new ODataMessageWriter(message as IODataResponseMessage, settings, model);
ODataMessageReader messageReader = new ODataMessageReader(message as IODataResponseMessage, new ODataMessageReaderSettings(), model);
ODataSerializerContext writeContext = new ODataSerializerContext {
RootElementName = "Property", Model = model
};
ODataDeserializerContext readContext = new ODataDeserializerContext {
Model = model
};
Type type = obj == null ? typeof(int) : obj.GetType();
await serializer.WriteObjectAsync(obj, type, messageWriter, writeContext);
stream.Seek(0, SeekOrigin.Begin);
// Act & Assert
Assert.NotNull(edmType);
Assert.NotNull(value);
Assert.Equal(obj, await deserializer.ReadAsync(messageReader, type, readContext));
}
public async Task WriteBatchRequestAsync_ThrowsExceptionForInvalidTransitionFromOperationStreamRequested()
{
var exception = await Assert.ThrowsAsync <ODataException>(
() => SetupJsonLightBatchWriterAndRunTestAsync(
async(jsonLightBatchWriter) =>
{
await jsonLightBatchWriter.WriteStartBatchAsync();
var operationRequestMessage = await jsonLightBatchWriter.CreateOperationRequestMessageAsync(
"POST", new Uri($"{ServiceUri}/Customers"), "1");
using (var messageWriter = new ODataMessageWriter(operationRequestMessage))
{
await messageWriter.CreateODataResourceWriterAsync(this.customerEntitySet, this.customerEntityType);
// Try to end writing batch after operation stream requested
await jsonLightBatchWriter.WriteEndBatchAsync();
}
}));
Assert.Equal(Strings.ODataBatchWriter_InvalidTransitionFromOperationContentStreamRequested, exception.Message);
}
public void Read_RoundTrips()
{
// Arrange
IEdmModel model = CreateModel();
var deserializer = new ODataEntityReferenceLinkDeserializer();
MockODataRequestMessage requestMessage = new MockODataRequestMessage();
ODataMessageWriterSettings settings = new ODataMessageWriterSettings()
{
ODataUri = new ODataUri {
ServiceRoot = new Uri("http://any/")
}
};
settings.SetContentType(ODataFormat.Json);
ODataMessageWriter messageWriter = new ODataMessageWriter(requestMessage, settings);
messageWriter.WriteEntityReferenceLink(new ODataEntityReferenceLink {
Url = new Uri("http://localhost/samplelink")
});
var request = RequestFactory.Create("Get", "http://localhost", opt => opt.AddModel("odata", model));
request.ODataFeature().PrefixName = "odata";
ODataMessageReaderSettings readSettings = new ODataMessageReaderSettings();
ODataMessageReader messageReader = new ODataMessageReader(new MockODataRequestMessage(requestMessage), readSettings, model);
ODataDeserializerContext context = new ODataDeserializerContext
{
Request = request,
Path = new ODataPath(new NavigationPropertySegment(GetNavigationProperty(model), navigationSource: null))
};
// Act
Uri uri = deserializer.Read(messageReader, typeof(Uri), context) as Uri;
// Assert
Assert.NotNull(uri);
Assert.Equal("http://localhost/samplelink", uri.AbsoluteUri);
}
private IEnumerable <KeyValuePair <string, string> > GetResponseMessageHeaders(Type graphType, ODataFormat odataFormat, ODataVersion version)
{
IODataResponseMessage responseMessage = new ODataMessageWrapper();
ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings()
{
BaseUri = new Uri(ODataFormatterConstants.DefaultNamespace),
Version = version,
Indent = false
};
writerSettings.SetContentType(odataFormat);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, writerSettings))
{
ODataSerializer serializer = ODataSerializerProvider.GetODataPayloadSerializer(graphType);
// get the OData specific headers for the payloadkind
ODataUtils.SetHeadersForPayload(messageWriter, serializer.ODataPayloadKind);
}
return(responseMessage.Headers);
}
