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.AreEqual("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); }
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); }
/// <summary> /// Constructor. /// </summary> /// <param name="format">The format for this output context.</param> /// <param name="messageStream">The message stream to write the payload to.</param> /// <param name="encoding">The encoding to use for the payload.</param> /// <param name="messageWriterSettings">Configuration settings of the OData writer.</param> /// <param name="writingResponse">true if writing a response message; otherwise false.</param> /// <param name="synchronous">true if the output should be written synchronously; false if it should be written asynchronously.</param> /// <param name="model">The model to use.</param> /// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs written to the payload.</param> internal ODataRawOutputContext( ODataFormat format, Stream messageStream, Encoding encoding, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver) : base(format, messageWriterSettings, writingResponse, synchronous, model, urlResolver) { Debug.Assert(messageStream != null, "messageStream != null"); try { this.messageOutputStream = messageStream; this.encoding = encoding; if (synchronous) { this.outputStream = messageStream; } else { this.asynchronousOutputStream = new AsyncBufferedStream(messageStream); this.outputStream = this.asynchronousOutputStream; } } catch { messageStream.Dispose(); throw; } }
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>(); }
public void WriteObject_WritesValueReturnedFrom_CreateODataCollectionValue() { // Arrange MemoryStream stream = new MemoryStream(); IODataResponseMessage message = new ODataMessageWrapper(stream); ODataMessageWriterSettings settings = new ODataMessageWriterSettings(); settings.SetContentType(ODataFormat.Atom); 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); XElement element = XElement.Load(stream); Assert.Equal("value", element.Name.LocalName); Assert.Equal(3, element.Descendants().Count()); Assert.Equal(new[] { "0", "1", "2" }, element.Descendants().Select(e => e.Value)); }
/// <summary> /// Initializes a new instance of the <see cref="RawValueWriter"/> class. /// Initializes the TextWriter. /// </summary> /// <param name="settings">The writer settings.</param> /// <param name="stream">The stream. It should be the same underlying stream the TextWriter uses.</param> /// <param name="encoding">The encoding to use in the text writer.</param> internal RawValueWriter(ODataMessageWriterSettings settings, Stream stream, Encoding encoding) { this.settings = settings; this.stream = stream; this.encoding = encoding; this.InitializeTextWriter(); }
/// <summary> /// Constructor. /// </summary> /// <param name="format">The format used for the test.</param> /// <param name="messageWriterSettings">The message writer settings used for the test.</param> /// <param name="IsRequest">True if the test is writing a request. Otherwise false if it's writing a response.</param> /// <param name="synchronous">True if the test should be ran using synchronous API. Otherwise false if it should be ran using asynchronous APIs.</param> public WriterTestConfiguration(ODataFormat format, ODataMessageWriterSettings messageWriterSettings, bool IsRequest, bool synchronous) : base(format, messageWriterSettings.Version.Value, IsRequest, TestODataBehaviorKind.Default) { Debug.Assert(messageWriterSettings != null, "messageWriterSettings != null"); this.Synchronous = synchronous; this.MessageWriterSettings = messageWriterSettings; }
public void Init() { model = new EdmModel(); stream = new MemoryStream(); settings = new ODataMessageWriterSettings { DisableMessageStreamDisposal = true, Version = ODataVersion.V4 }; settings.SetServiceDocumentUri(new Uri("http://example.com")); }
public void ODataEntityReferenceLinkSerializer_Serializes_UrisAndEntityReferenceLinks(object uris) { // Arrange ODataEntityReferenceLinksSerializer serializer = new ODataEntityReferenceLinksSerializer(); ODataSerializerContext writeContext = new ODataSerializerContext(); MemoryStream stream = new MemoryStream(); IODataResponseMessage message = new ODataMessageWrapper(stream); ODataMessageWriterSettings settings = new ODataMessageWriterSettings { ODataUri = new ODataUri { ServiceRoot = new Uri("http://any/") } }; settings.SetContentType(ODataFormat.Json); ODataMessageWriter writer = new ODataMessageWriter(message, settings); // Act serializer.WriteObject(uris, typeof(ODataEntityReferenceLinks), writer, writeContext); stream.Seek(0, SeekOrigin.Begin); string result = new StreamReader(stream).ReadToEnd(); // Assert Assert.Equal("{\"@odata.context\":\"http://any/$metadata#Collection($ref)\"," + "\"value\":[{\"@odata.id\":\"http://uri1/\"},{\"@odata.id\":\"http://uri2/\"}]}", result); }
internal ODataMetadataOutputContext( ODataFormat format, Stream messageStream, Encoding encoding, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver) : base(format, messageWriterSettings, writingResponse, synchronous, model, urlResolver) { Debug.Assert(messageStream != null, "messageStream != null"); Debug.Assert(synchronous, "Metadata output context is only supported in synchronous operations."); try { this.messageOutputStream = messageStream; this.xmlWriter = ODataAtomWriterUtils.CreateXmlWriter(messageStream, messageWriterSettings, encoding); } catch (Exception e) { // Dispose the message stream if we failed to create the output context. if (ExceptionUtils.IsCatchableExceptionType(e) && messageStream != null) { messageStream.Dispose(); } throw; } }
public void Initialize() { var model = new EdmModel(); var type = new EdmEntityType("TestModel", "TestEntity", /* baseType */ null, /* isAbstract */ false, /* isOpen */ true); var keyProperty = type.AddStructuralProperty("DeclaredInt16", EdmPrimitiveTypeKind.Int16); type.AddKeys(new[] { keyProperty }); // Note: DerivedPrimitive is declared as a Geography, but its value below will be set to GeographyPoint, which is derived from Geography. type.AddStructuralProperty("DerivedPrimitive", EdmPrimitiveTypeKind.Geography); var container = new EdmEntityContainer("TestModel", "Container"); var set = container.AddEntitySet("Set", type); model.AddElement(type); model.AddElement(container); var writerStream = new MemoryStream(); this.settings = new ODataMessageWriterSettings(); this.settings.SetServiceDocumentUri(ServiceDocumentUri); // Make the message writer and entry writer lazy so that individual tests can tweak the settings before the message writer is created. this.messageWriter = new Lazy<ODataMessageWriter>(() => new ODataMessageWriter( (IODataResponseMessage)new InMemoryMessage { Stream = writerStream }, this.settings, model)); var entryWriter = new Lazy<ODataWriter>(() => this.messageWriter.Value.CreateODataEntryWriter(set, type)); var valueWithAnnotation = new ODataPrimitiveValue(45); valueWithAnnotation.SetAnnotation(new SerializationTypeNameAnnotation { TypeName = "TypeNameFromSTNA" }); var propertiesToWrite = new List<ODataProperty> { new ODataProperty { Name = "DeclaredInt16", Value = (Int16)42 }, new ODataProperty { Name = "UndeclaredDecimal", Value = (Decimal)4.5 }, new ODataProperty { // Note: value is more derived than the declared type. Name = "DerivedPrimitive", Value = Microsoft.Spatial.GeographyPoint.Create(42, 45) }, new ODataProperty() { Name = "PropertyWithSTNA", Value = valueWithAnnotation } }; this.writerOutput = new Lazy<string>(() => { entryWriter.Value.WriteStart(new ODataEntry { Properties = propertiesToWrite }); entryWriter.Value.WriteEnd(); entryWriter.Value.Flush(); writerStream.Seek(0, SeekOrigin.Begin); return new StreamReader(writerStream).ReadToEnd(); }); }
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); }
public void WriteObject_Calls_CreateODataComplexValue() { // 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<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); string result = new StreamReader(stream).ReadToEnd(); Assert.Equal("{\"@odata.context\":\"http://any/$metadata#NS.Name\",\"Property1\":42}", result); }
/// <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; } }
/// <summary> /// Create message writer settings for producing requests. /// </summary> /// <param name="isBatchPartRequest">if set to <c>true</c> indicates that this is a part of a batch request.</param> /// <param name="enableAtom">Whether to enable ATOM.</param> /// <param name="odataSimplified">Whether to enable OData Simplified.</param> /// <returns>Newly created message writer settings.</returns> internal ODataMessageWriterSettings CreateSettings(bool isBatchPartRequest, bool enableAtom, bool odataSimplified) { ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings { CheckCharacters = false, Indent = false, ODataSimplified = odataSimplified, // For operations inside batch, we need to dispose the stream. For top level requests, // we do not need to dispose the stream. Since for inner batch requests, the request // message is an internal implementation of IODataRequestMessage in ODataLib, // we can do this here. DisableMessageStreamDisposal = !isBatchPartRequest }; #if !DNXCORE50 if (enableAtom) { // Enable ATOM for client writerSettings.EnableAtomSupport(); } #endif CommonUtil.SetDefaultMessageQuotas(writerSettings.MessageQuotas); // Enable the Astoria client behavior in ODataLib. writerSettings.EnableWcfDataServicesClientBehavior(); this.requestInfo.Configurations.RequestPipeline.ExecuteWriterSettingsConfiguration(writerSettings); return writerSettings; }
public void Init() { EdmModel model = new EdmModel(); EdmComplexType complex1 = new EdmComplexType("ns", "complex1"); complex1.AddProperty(new EdmStructuralProperty(complex1, "p1", EdmCoreModel.Instance.GetInt32(isNullable: false))); model.AddElement(complex1); EdmComplexType complex2 = new EdmComplexType("ns", "complex2"); complex2.AddProperty(new EdmStructuralProperty(complex2, "p1", EdmCoreModel.Instance.GetInt32(isNullable: false))); model.AddElement(complex2); EdmComplexTypeReference complex2Reference = new EdmComplexTypeReference(complex2, isNullable: false); EdmCollectionType primitiveCollectionType = new EdmCollectionType(EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false)); EdmCollectionType complexCollectionType = new EdmCollectionType(complex2Reference); EdmCollectionTypeReference primitiveCollectionTypeReference = new EdmCollectionTypeReference(primitiveCollectionType); EdmCollectionTypeReference complexCollectionTypeReference = new EdmCollectionTypeReference(complexCollectionType); model.AddElement(new EdmTerm("custom", "int", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false))); model.AddElement(new EdmTerm("custom", "string", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.String, isNullable: false))); model.AddElement(new EdmTerm("custom", "double", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Double, isNullable: false))); model.AddElement(new EdmTerm("custom", "bool", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: true))); model.AddElement(new EdmTerm("custom", "decimal", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Decimal, isNullable: false))); model.AddElement(new EdmTerm("custom", "timespan", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Duration, isNullable: false))); model.AddElement(new EdmTerm("custom", "guid", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Guid, isNullable: false))); model.AddElement(new EdmTerm("custom", "complex", complex2Reference)); model.AddElement(new EdmTerm("custom", "primitiveCollection", primitiveCollectionTypeReference)); model.AddElement(new EdmTerm("custom", "complexCollection", complexCollectionTypeReference)); this.stream = new MemoryStream(); this.settings = new ODataMessageWriterSettings { Version = ODataVersion.V4, ShouldIncludeAnnotation = ODataUtils.CreateAnnotationFilter("*") }; this.settings.SetServiceDocumentUri(ServiceDocumentUri); this.serializer = new ODataAtomPropertyAndValueSerializer(this.CreateAtomOutputContext(model, this.stream)); }
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); } }
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); }
/// <summary> /// Initializes a new instance of the <see cref="ODataMediaTypeFormatter"/> class. /// </summary> /// <param name="deserializerProvider">The <see cref="ODataDeserializerProvider"/> to use.</param> /// <param name="serializerProvider">The <see cref="ODataSerializerProvider"/> to use.</param> /// <param name="payloadKinds">The kind of payloads this formatter supports.</param> public ODataMediaTypeFormatter(ODataDeserializerProvider deserializerProvider, ODataSerializerProvider serializerProvider, IEnumerable<ODataPayloadKind> payloadKinds) { if (deserializerProvider == null) { throw Error.ArgumentNull("deserializerProvider"); } if (serializerProvider == null) { throw Error.ArgumentNull("serializerProvider"); } if (payloadKinds == null) { throw Error.ArgumentNull("payloadKinds"); } _deserializerProvider = deserializerProvider; _serializerProvider = serializerProvider; _payloadKinds = payloadKinds; // Maxing out the received message size as we depend on the hosting layer to enforce this limit. MessageWriterSettings = new ODataMessageWriterSettings { Indent = true, DisableMessageStreamDisposal = true, MessageQuotas = new ODataMessageQuotas { MaxReceivedMessageSize = Int64.MaxValue } }; MessageReaderSettings = new ODataMessageReaderSettings { DisableMessageStreamDisposal = true, MessageQuotas = new ODataMessageQuotas { MaxReceivedMessageSize = Int64.MaxValue }, }; _version = DefaultODataVersion; }
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 WriterSettingsIntegrationTest() { var settings = new ODataMessageWriterSettings(); settings.SetServiceDocumentUri(ServiceDocumentUri); settings.MetadataDocumentUri.Should().Equals(ServiceDocumentUri + "/$metadata"); settings.SetServiceDocumentUri(null); settings.MetadataDocumentUri.Should().BeNull(); }
public void WriteInstanceAnnotationShouldSkipAnnotationBaseOnAnnotationFilter() { this.settings = new ODataMessageWriterSettings {Version = ODataVersion.V4, ShouldIncludeAnnotation = name => false}; this.serializer = new ODataAtomPropertyAndValueSerializer(this.CreateAtomOutputContext(EdmCoreModel.Instance, this.stream)); var annotation = AtomInstanceAnnotation.CreateFrom(new ODataInstanceAnnotation("Namespace.TermName", new ODataPrimitiveValue("string value")), /*target*/ null); this.serializer.WriteInstanceAnnotation(annotation); this.ValidatePayload(""); }
protected override ODataMessageWriterSettings GetWriterSettings() { ODataMessageWriterSettings settings = new ODataMessageWriterSettings { PayloadBaseUri = this.ServiceRootUri }; settings.SetContentType(ODataFormat.Json); return settings; }
protected override ODataMessageWriterSettings GetWriterSettings() { ODataMessageWriterSettings settings = new ODataMessageWriterSettings { AutoComputePayloadMetadataInJson = true, PayloadBaseUri = this.ServiceRootUri }; return settings; }
/// <summary> /// Prevents a default instance of the <see cref="MessageWriterBuilder"/> class from being created. /// </summary> /// <param name="serviceUri">The service URI.</param> /// <param name="responseVersion">The response version.</param> /// <param name="dataService">The data service.</param> /// <param name="responseMessage">The response message.</param> /// <param name="model">The model to provide to the message writer.</param> private MessageWriterBuilder(Uri serviceUri, Version responseVersion, IDataService dataService, IODataResponseMessage responseMessage, IEdmModel model) { this.writerSettings = CreateMessageWriterSettings(); ApplyCommonSettings(this.writerSettings, serviceUri, responseVersion, dataService, responseMessage); Debug.Assert(responseMessage != null, "responseMessage != null"); this.responseMessage = responseMessage; this.model = model; }
public CsvOutputContext( ODataFormat format, ODataMessageWriterSettings settings, ODataMessageInfo messageInfo, bool synchronous) : base(format, settings, messageInfo.IsResponse, synchronous, messageInfo.Model, messageInfo.UrlResolver) { this.stream = messageInfo.GetMessageStream(); this.Writer = new StreamWriter(this.stream); }
public void WriterShouldNotIncludeTypeNameForCollectionOfDerivedType() { // JSON Light: writer doesn't include type name for collection of derived type // If I have a collection property declared in metadata as Collection(Edm.Geography), // and at serialization type, it's clearly a Collection(Edm.GeographyPoint), // we won't write the type name for that property by default (i.e., minimal metadata mode). var model = new EdmModel(); var entityType = new EdmEntityType("Var1", "Type"); entityType.AddKeys(entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32)); entityType.AddProperty(new EdmStructuralProperty(entityType, "Geographies", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetSpatial(EdmPrimitiveTypeKind.Geography, false))))); model.AddElement(entityType); var writerSettings = new ODataMessageWriterSettings(); writerSettings.SetContentType(ODataFormat.Json); writerSettings.DisableMessageStreamDisposal = true; var message = new InMemoryMessage { Stream = new MemoryStream() }; using (ODataMessageWriter odataMessageWriter = new ODataMessageWriter((IODataRequestMessage)message, writerSettings, model)) { ODataWriter odataWriter = odataMessageWriter.CreateODataEntryWriter(); odataWriter.WriteStart( new ODataEntry { TypeName = "Var1.Type", Properties = new[] { new ODataProperty() { Name = "Id", Value = 1 }, new ODataProperty() { Name = "Geographies", Value = new ODataCollectionValue { Items = new[] { GeographyPoint.Create(0,0), GeographyPoint.Create(1,1), GeographyPoint.Create(2,2) } } }, } }); odataWriter.WriteEnd(); odataWriter.Flush(); } message.Stream.Position = 0; var output = new StreamReader(message.Stream).ReadToEnd(); Assert.IsFalse(output.Contains("Collection(Edm.GeographyPoint)"), @"output.Contains(""Collection(Edm.GeographyPoint)"" == false"); }
private static void CsvWriterDemo() { EdmEntityType customer = new EdmEntityType("ns", "customer"); var key = customer.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32); customer.AddKeys(key); customer.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String); ODataEntry entry1 = new ODataEntry() { Properties = new[] { new ODataProperty(){Name = "Id", Value = 51}, new ODataProperty(){Name = "Name", Value = "Name_A"}, } }; ODataEntry entry2 = new ODataEntry() { Properties = new[] { new ODataProperty(){Name = "Id", Value = 52}, new ODataProperty(){Name = "Name", Value = "Name_B"}, } }; var stream = new MemoryStream(); var message = new Message { Stream = stream }; // Set Content-Type header value message.SetHeader("Content-Type", "text/csv"); var settings = new ODataMessageWriterSettings { // Set our resolver here. MediaTypeResolver = CsvMediaTypeResolver.Instance, DisableMessageStreamDisposal = true, }; using (var messageWriter = new ODataMessageWriter(message, settings)) { var writer = messageWriter.CreateODataFeedWriter(null, customer); writer.WriteStart(new ODataFeed()); writer.WriteStart(entry1); writer.WriteEnd(); writer.WriteStart(entry2); writer.WriteEnd(); writer.WriteEnd(); writer.Flush(); } stream.Seek(0, SeekOrigin.Begin); string msg; using (var sr = new StreamReader(stream)) { msg = sr.ReadToEnd(); } Console.WriteLine(msg); }
public void Init() { model = new EdmModel(); EdmComplexType complexType = new EdmComplexType("ns", "complex"); complexType.AddProperty(new EdmStructuralProperty(complexType, "StringProperty", EdmCoreModel.Instance.GetString(isNullable: false))); model.AddElement(complexType); this.stream = new MemoryStream(); this.settings = new ODataMessageWriterSettings { Version = ODataVersion.V4, ShouldIncludeAnnotation = ODataUtils.CreateAnnotationFilter("*") }; this.settings.SetServiceDocumentUri(ServiceDocumentUri); this.serializer = new ODataAtomPropertyAndValueSerializer(this.CreateAtomOutputContext(model, this.stream)); this.instanceAnnotationWriteTracker = new InstanceAnnotationWriteTracker(); }
public ODataOutputFormatter(ODataSerializerProvider serializerProvider, IEnumerable<ODataPayloadKind> payloadKinds) { _messageWriterSettings = new ODataMessageWriterSettings { Indent = true, DisableMessageStreamDisposal = true, MessageQuotas = new ODataMessageQuotas { MaxReceivedMessageSize = Int64.MaxValue }, AutoComputePayloadMetadataInJson = true, }; _serializerProvider = serializerProvider; _payloadKinds = payloadKinds; }
/// <summary> /// Validates that message writer settings are correct. /// </summary> /// <param name="messageWriterSettings">The message writer settings to validate.</param> /// <param name="writingResponse">True if we are writing a response.</param> public void ValidateMessageWriterSettings(ODataMessageWriterSettings messageWriterSettings, bool writingResponse) { WriterValidationUtils.ValidateMessageWriterSettings(messageWriterSettings, writingResponse); }