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); }