public void ShouldBeAbleToSetTheFeedSerializationInfo()
{
ODataFeed feed = new ODataFeed();
ODataFeedAndEntrySerializationInfo serializationInfo = new ODataFeedAndEntrySerializationInfo { NavigationSourceName = "Set", NavigationSourceEntityTypeName = "ns.base", ExpectedTypeName = "ns.expected" };
feed.SetSerializationInfo(serializationInfo);
feed.SerializationInfo.Should().BeSameAs(serializationInfo);
}
/// <summary>
/// Creates the materializer link with a feed.
/// </summary>
/// <param name="link">The link.</param>
/// <param name="feed">The feed.</param>
/// <returns>The materializer link.</returns>
public static MaterializerNavigationLink CreateLink(ODataNavigationLink link, ODataFeed feed)
{
Debug.Assert(link.GetAnnotation<MaterializerNavigationLink>() == null, "there should be no MaterializerNavigationLink annotation on the feed link yet");
MaterializerNavigationLink materializedNavigationLink = new MaterializerNavigationLink(link, feed);
link.SetAnnotation<MaterializerNavigationLink>(materializedNavigationLink);
return materializedNavigationLink;
}
/// <summary>
/// Visits an entity set instance: creates a new ODataFeed instance, calls ODataWriter.WriteStart()
/// before visiting the entries and then calls ODataWriter.WriteEnd()
/// </summary>
/// <param name="payloadElement">The entity set instance to write.</param>
public override void Visit(EntitySetInstance payloadElement)
{
// create an ODataFeed and write it
ODataFeed feed = new ODataFeed()
{
// NOTE: the required Id is set when processing the annotations in AddFeedMetadata()
Count = payloadElement.InlineCount,
SerializationInfo = new ODataFeedAndEntrySerializationInfo()
{
NavigationSourceEntityTypeName = "Null",
NavigationSourceName = "MySet",
ExpectedTypeName = "Null"
}
};
if (payloadElement.NextLink != null)
{
feed.NextPageLink = new Uri(payloadElement.NextLink);
}
AddFeedMetadata(payloadElement, feed);
this.writer.WriteStart(feed);
base.Visit(payloadElement);
this.writer.WriteEnd();
}
/// <summary>
/// Prevents a default instance of the <see cref="MaterializerFeed"/> struct from being created.
/// </summary>
/// <param name="feed">The feed.</param>
/// <param name="entries">The entries.</param>
private MaterializerFeed(ODataFeed feed, IEnumerable<ODataEntry> entries)
{
Debug.Assert(feed != null, "feed != null");
Debug.Assert(entries != null, "entries != null");
this.feed = feed;
this.entries = entries;
}
/// <summary>
/// Visits an entity set instance: creates a new ODataFeed instance, calls ODataWriter.WriteStart()
/// before visiting the entries and then calls ODataWriter.WriteEnd()
/// </summary>
/// <param name="payloadElement">The entity set instance to write.</param>
public override void Visit(EntitySetInstance payloadElement)
{
// create an ODataFeed and write it
ODataFeed feed = new ODataFeed()
{
// NOTE: the required Id is set when processing the annotations in AddFeedMetadata()
Count = payloadElement.InlineCount,
SerializationInfo = new ODataFeedAndEntrySerializationInfo() {
NavigationSourceEntityTypeName = "Null",
NavigationSourceName = "MySet",
ExpectedTypeName = "Null"
}
};
var idAnnotation = payloadElement.Annotations.Where(a =>
{
var annotation = a as XmlTreeAnnotation;
if (annotation != null)
return annotation.LocalName.Equals("id");
return false;
}).SingleOrDefault();
if (idAnnotation != null)
{
feed.Id = new Uri((idAnnotation as XmlTreeAnnotation).PropertyValue, UriKind.Absolute);
}
if (payloadElement.NextLink != null)
{
feed.NextPageLink = new Uri(payloadElement.NextLink);
}
AddFeedMetadata(payloadElement, feed);
if (this.items.Count > 0 && this.items.Peek() is ODataNavigationLink)
{
var currentLink = this.items.Peek() as ODataNavigationLink;
ExceptionUtilities.CheckObjectNotNull(currentLink, "Feed can only exist at top level or inside a navigation link");
currentLink.SetAnnotation(new ODataNavigationLinkExpandedItemObjectModelAnnotation() { ExpandedItem = feed });
}
try
{
items.Push(feed);
base.Visit(payloadElement);
}
finally
{
feed = (ODataFeed)items.Pop();
}
// If we are at the top level push this to items to make it the result.
if (this.items.Count == 0)
{
this.items.Push(feed);
}
}
public void PropertySettersNullTest()
{
ODataFeed feed = new ODataFeed();
feed.Count = null;
feed.NextPageLink = null;
this.Assert.IsNull(feed.Count, "Expected null value for property 'Count'.");
this.Assert.IsNull(feed.NextPageLink, "Expected null value for property 'NextPageLink'.");
}
/// <summary>
/// Creates a new instance of DataServiceODataWriterFeedArgs
/// </summary>
/// <param name="feed">ODataFeed instance.</param>
/// <param name="results">IEnumerable instance that is getting serialized.</param>
/// <param name="operationContext">DataServiceOperationContext instance.</param>
public DataServiceODataWriterFeedArgs(ODataFeed feed, IEnumerable results, DataServiceOperationContext operationContext)
{
WebUtil.CheckArgumentNull(feed, "feed");
Debug.Assert(results != null, "results != null");
Debug.Assert(operationContext != null, "operationContext != null");
this.Feed = feed;
this.Results = results;
this.OperationContext = operationContext;
}
/// <summary>
/// Initializes a new instance of the <see cref="FeedAndEntryMaterializerAdapter"/> class. Used for tests so no ODataMessageReader is required
/// </summary>
/// <param name="odataFormat">The format of the reader.</param>
/// <param name="reader">The reader.</param>
/// <param name="model">The model.</param>
/// <param name="mergeOption">The mergeOption.</param>
internal FeedAndEntryMaterializerAdapter(ODataFormat odataFormat, ODataReaderWrapper reader, ClientEdmModel model, MergeOption mergeOption)
{
this.readODataFormat = odataFormat;
this.clientEdmModel = model;
this.mergeOption = mergeOption;
this.reader = reader;
this.currentEntry = null;
this.currentFeed = null;
this.feedEntries = null;
}
/// <summary>
/// Writes an OData feed.
/// </summary>
/// <param name="writer">The ODataWriter that will write the feed.</param>
/// <param name="entries">The items from the data store to write to the feed.</param>
/// <param name="entitySet">The entity set in the model that the feed belongs to.</param>
/// <param name="model">The data store model.</param>
/// <param name="targetVersion">The OData version this segment is targeting.</param>
/// <param name="expandedNavigationProperties">A list of navigation property names to expand.</param>
public static void WriteFeed(ODataWriter writer, IEnumerable entries, IEdmEntitySet entitySet, IEdmModel model, ODataVersion targetVersion, IEnumerable<string> expandedNavigationProperties)
{
var feed = new ODataFeed {Id = new Uri(ServiceConstants.ServiceBaseUri, entitySet.Name)};
writer.WriteStart(feed);
foreach (var element in entries)
{
WriteEntry(writer, element, entitySet, model, targetVersion, expandedNavigationProperties);
}
writer.WriteEnd();
}
/// <summary>
/// Visits a feed item.
/// </summary>
/// <param name="feed">The feed to visit.</param>
protected override ODataPayloadElement VisitFeed(ODataFeed feed)
{
ODataPayloadElement payloadElement = base.VisitFeed(feed);
ODataFeedPayloadOrderObjectModelAnnotation payloadOrderFeedAnnotation = feed.GetAnnotation<ODataFeedPayloadOrderObjectModelAnnotation>();
if (payloadOrderFeedAnnotation != null)
{
PayloadOrderODataPayloadElementAnnotation payloadOrderElementAnnotation = new PayloadOrderODataPayloadElementAnnotation();
payloadOrderElementAnnotation.PayloadItems.AddRange(payloadOrderFeedAnnotation.PayloadItems);
payloadElement.Add(payloadOrderElementAnnotation);
}
return payloadElement;
}
/// <summary>
/// Creates the materializer feed.
/// </summary>
/// <param name="feed">The feed.</param>
/// <param name="entries">The entries.</param>
/// <returns>The materializer feed.</returns>
public static MaterializerFeed CreateFeed(ODataFeed feed, IEnumerable<ODataEntry> entries)
{
Debug.Assert(feed.GetAnnotation<IEnumerable<ODataEntry>>() == null, "Feed state has already been created.");
if (entries == null)
{
entries = Enumerable.Empty<ODataEntry>();
}
else
{
feed.SetAnnotation<IEnumerable<ODataEntry>>(entries);
}
return new MaterializerFeed(feed, entries);
}
public void PropertyGettersAndSettersTest()
{
int count = -2;
Uri nextPageLink = new Uri("http://odatatest.org/page?id=2");
ODataFeed feed = new ODataFeed()
{
Count = count,
NextPageLink = nextPageLink
};
this.Assert.AreEqual(count, feed.Count, EqualityComparer<long?>.Default, "Expected equal Count values.");
this.Assert.AreSame(nextPageLink, feed.NextPageLink, "Expected reference equal values for property 'NextPageLink'.");
}
/// <summary>
/// Start writing a feed.
/// </summary>
/// <param name="feed">Feed/collection to write.</param>
public override void WriteStart(ODataFeed feed)
{
if (this.testConfiguration.Synchronous)
{
this.writer.WriteStart(feed);
}
else
{
#if WINDOWS_PHONE
throw new TaupoNotSupportedException("This test is not supported in asynchronous mode in Silverlight or Windows Phone");
#else
this.writer.WriteStartAsync(feed).Wait();
#endif
}
}
public void WriteStartShouldIgnoreDeltaLinkWhenWritingResponseTopLevelFeed()
{
string expectedPayload =
@"<?xml version=""1.0"" encoding=""utf-8""?>"
+ @"<feed xmlns=""http://www.w3.org/2005/Atom"" xmlns:d=""http://docs.oasis-open.org/odata/ns/data"" xmlns:m=""http://docs.oasis-open.org/odata/ns/metadata"" xmlns:georss=""http://www.georss.org/georss"" xmlns:gml=""http://www.opengis.net/gml"" m:context=""http://www.example.com/$metadata#TestEntitySet"">"
+ "<id>http://host/TestEntitySet</id>"
+ "<title />";
Action<ODataWriter> deltaLinkAtWriteStart = (odataWriter) =>
{
var feedToWrite = new ODataFeed { Id = new Uri("http://host/TestEntitySet", UriKind.Absolute), DeltaLink = new Uri("http://host/deltaLink", UriKind.Absolute) };
odataWriter.WriteStart(feedToWrite);
};
WriteAnnotationsAndValidatePayload(deltaLinkAtWriteStart, ODataFormat.Atom, expectedPayload, request: false, createFeedWriter: true);
}
public void ValidateShortIntegrationFeedReading()
{
var initialFeed = new ODataFeed() {Id = new Uri("http://services.odata.org/OData/OData.svc/Products")};
var productItem = new ODataEntry() {Id = new Uri("http://services.odata.org/OData/OData.svc/Products(0)")};
productItem.Properties = new ODataProperty[] {new ODataProperty() {Name = "Id", Value = 0}};
var categoryNavigationLink = new ODataNavigationLink() {Name = "Category"};
var categoryItem = new ODataEntry() { Id = new Uri("http://services.odata.org/OData/OData.svc/Categories(0)") };
categoryItem.Properties = new ODataProperty[] { new ODataProperty() { Name = "Id", Value = 0 } };
var productsNavigationLink = new ODataNavigationLink() { Name = "Products" };
var supplierNavigationLink = new ODataNavigationLink() { Name = "Supplier" };
var testODataReader = new TestODataReader()
{
new TestODataReaderItem(ODataReaderState.FeedStart, initialFeed),
new TestODataReaderItem(ODataReaderState.EntryStart, productItem),
new TestODataReaderItem(ODataReaderState.NavigationLinkStart, categoryNavigationLink),
new TestODataReaderItem(ODataReaderState.EntryStart, categoryItem),
new TestODataReaderItem(ODataReaderState.NavigationLinkStart, productsNavigationLink),
new TestODataReaderItem(ODataReaderState.NavigationLinkEnd, productsNavigationLink),
new TestODataReaderItem(ODataReaderState.EntryEnd, categoryItem),
new TestODataReaderItem(ODataReaderState.NavigationLinkEnd, categoryNavigationLink),
new TestODataReaderItem(ODataReaderState.NavigationLinkStart, supplierNavigationLink),
new TestODataReaderItem(ODataReaderState.NavigationLinkEnd, supplierNavigationLink),
new TestODataReaderItem(ODataReaderState.EntryEnd, productItem),
new TestODataReaderItem(ODataReaderState.FeedEnd, initialFeed),
};
ClientEdmModel clientEdmModel = new ClientEdmModel(ODataProtocolVersion.V4);
var responsePipeline = new DataServiceClientResponsePipelineConfiguration(new DataServiceContext());
var odataReaderWrapper = ODataReaderWrapper.CreateForTest(testODataReader, responsePipeline);
FeedAndEntryMaterializerAdapter reader = new FeedAndEntryMaterializerAdapter(ODataFormat.Atom, odataReaderWrapper, clientEdmModel, MergeOption.OverwriteChanges);
int readCounter = 0;
while (reader.Read())
{
readCounter++;
}
readCounter.Should().Be(2);
}
public void WriteStartShouldIgnoreDeltaLinkWhenWritingRequestTopLevelFeed()
{
string expectedPayload =
"{" +
"\"@odata.context\":\"http://www.example.com/$metadata#TestEntitySet\"," +
"\"value\":[]" +
"}";
Action<ODataWriter> deltaLinkAtWriteStart = (odataWriter) =>
{
var feedToWrite = new ODataFeed { DeltaLink = new Uri("http://host/deltaLink", UriKind.Absolute) };
odataWriter.WriteStart(feedToWrite);
odataWriter.WriteEnd();
};
WriteAnnotationsAndValidatePayload(deltaLinkAtWriteStart, ODataFormat.Json, expectedPayload, request: true, createFeedWriter: true);
}
/// <summary> /// Asynchronously start writing an expanded feed. /// </summary> /// <param name="expandedFeed">The expanded feed to write.</param> /// <returns>A task instance that represents the asynchronous write operation.</returns> public abstract Task WriteStartAsync(ODataFeed expandedFeed);
/// <summary> /// Start writing an expanded feed. /// </summary> /// <param name="expandedFeed">The expanded feed to write.</param> public abstract void WriteStart(ODataFeed expandedFeed);
public void WriteObjectInline_Sets_NextPageLink_OnWriteEnd()
{
// Arrange
IEnumerable instance = new object[0];
ODataFeed feed = new ODataFeed { NextPageLink = new Uri("http://nextlink.com/") };
Mock<ODataFeedSerializer> serializer = new Mock<ODataFeedSerializer>(new DefaultODataSerializerProvider());
serializer.CallBase = true;
serializer.Setup(s => s.CreateODataFeed(instance, _customersType, _writeContext)).Returns(feed);
var mockWriter = new Mock<ODataWriter>();
mockWriter.Setup(m => m.WriteStart(It.Is<ODataFeed>(f => f.NextPageLink == null))).Verifiable();
mockWriter
.Setup(m => m.WriteEnd())
.Callback(() =>
{
Assert.Equal("http://nextlink.com/", feed.NextPageLink.AbsoluteUri);
})
.Verifiable();
// Act
serializer.Object.WriteObjectInline(instance, _customersType, mockWriter.Object, _writeContext);
// Assert
mockWriter.Verify();
}
public void WriteObjectInline_Sets_CountQueryOption_OnWriteStart()
{
// Arrange
IEnumerable instance = new object[0];
ODataFeed feed = new ODataFeed { Count = 1000 };
Mock<ODataFeedSerializer> serializer = new Mock<ODataFeedSerializer>(new DefaultODataSerializerProvider());
serializer.CallBase = true;
serializer.Setup(s => s.CreateODataFeed(instance, _customersType, _writeContext)).Returns(feed);
var mockWriter = new Mock<ODataWriter>();
mockWriter.Setup(m => m.WriteStart(It.Is<ODataFeed>(f => f.Count == 1000))).Verifiable();
// Act
serializer.Object.WriteObjectInline(instance, _customersType, mockWriter.Object, _writeContext);
// Assert
mockWriter.Verify();
}
/// <summary>
/// Read a feed or entry, with the expected type.
/// </summary>
/// <returns>true if a value was read, otherwise false</returns>
public bool Read()
{
if (this.feedEntries != null)
{
// ISSUE: this might throw - refactor?
if (this.feedEntries.MoveNext())
{
this.currentEntry = this.feedEntries.Current;
return true;
}
else
{
this.feedEntries = null;
this.currentEntry = null;
}
}
switch (this.reader.State)
{
case ODataReaderState.Completed:
this.currentEntry = null;
return false;
case ODataReaderState.Start:
{
ODataFeed feed;
MaterializerEntry entryAndState;
if (this.TryReadFeedOrEntry(true, out feed, out entryAndState))
{
this.currentEntry = entryAndState != null ? entryAndState.Entry : null;
this.currentFeed = feed;
if (this.currentFeed != null)
{
this.feedEntries = MaterializerFeed.GetFeed(this.currentFeed).Entries.GetEnumerator();
}
return true;
}
else
{
throw new NotImplementedException();
}
}
case ODataReaderState.FeedEnd:
case ODataReaderState.EntryEnd:
if (this.TryRead() || this.reader.State != ODataReaderState.Completed)
{
throw DSClient.Error.InternalError(InternalError.UnexpectedReadState);
}
this.currentEntry = null;
return false;
default:
throw DSClient.Error.InternalError(InternalError.UnexpectedReadState);
}
}
public void WriteEndOnExpandedFeedWithDeltaLinkShouldThrow()
{
Action<ODataWriter> deltaLinkAtWriteStart = (odataWriter) =>
{
var entryToWrite = new ODataEntry { Properties = new[] { new ODataProperty { Name = "ID", Value = 1 } } };
odataWriter.WriteStart(entryToWrite);
ODataNavigationLink navLink = new ODataNavigationLink { Name = "ResourceSetNavigationProperty", IsCollection = true, Url = new Uri("http://host/navProp") };
odataWriter.WriteStart(navLink);
var feedToWrite = new ODataFeed() { Id = new Uri("http://host/TestEntitySet", UriKind.Absolute) };
feedToWrite.DeltaLink = new Uri("http://host/relative", UriKind.Absolute);
odataWriter.WriteStart(feedToWrite);
odataWriter.WriteEnd();
};
Action requestTest = () => WriteAnnotationsAndValidatePayload(deltaLinkAtWriteStart, ODataFormat.Atom, string.Empty, request: true, createFeedWriter: false);
requestTest.ShouldThrow<ODataException>().WithMessage(Strings.ODataWriterCore_DeltaLinkNotSupportedOnExpandedFeed);
Action responseTest = () => WriteAnnotationsAndValidatePayload(deltaLinkAtWriteStart, ODataFormat.Atom, string.Empty, request: false, createFeedWriter: false);
responseTest.ShouldThrow<ODataException>().WithMessage(Strings.ODataWriterCore_DeltaLinkNotSupportedOnExpandedFeed);
}
private async Task WriteOperationParameterAsync(ODataParameterWriter parameterWriter, IEdmOperationParameter operationParameter, string paramName, object paramValue)
{
switch (operationParameter.Type.Definition.TypeKind)
{
case EdmTypeKind.Primitive:
case EdmTypeKind.Enum:
case EdmTypeKind.Complex:
await parameterWriter.WriteValueAsync(paramName, paramValue);
break;
case EdmTypeKind.Entity:
var entryWriter = await parameterWriter.CreateEntryWriterAsync(paramName);
var entry = CreateODataEntry(operationParameter.Type.Definition.FullTypeName(), paramValue.ToDictionary());
await entryWriter.WriteStartAsync(entry);
await entryWriter.WriteEndAsync();
break;
case EdmTypeKind.Collection:
var collectionType = operationParameter.Type.Definition as IEdmCollectionType;
var elementType = collectionType.ElementType;
if (elementType.Definition.TypeKind == EdmTypeKind.Entity)
{
var feedWriter = await parameterWriter.CreateFeedWriterAsync(paramName);
var feed = new ODataFeed();
await feedWriter.WriteStartAsync(feed);
foreach (var item in paramValue as IEnumerable)
{
var feedEntry = CreateODataEntry(elementType.Definition.FullTypeName(), item.ToDictionary());
await feedWriter.WriteStartAsync(feedEntry);
await feedWriter.WriteEndAsync();
}
await feedWriter.WriteEndAsync();
}
else
{
var collectionWriter = await parameterWriter.CreateCollectionWriterAsync(paramName);
await collectionWriter.WriteStartAsync(new ODataCollectionStart());
foreach (var item in paramValue as IEnumerable)
{
await collectionWriter.WriteItemAsync(item);
}
await collectionWriter.WriteEndAsync();
}
break;
default:
throw new NotSupportedException(string.Format("Unable to write action parameter of a type {0}", operationParameter.Type.Definition.TypeKind));
}
}
/// <summary>
/// Visits a feed item.
/// </summary>
/// <param name="feed">The feed to visit.</param>
protected override void VisitFeed(ODataFeed feed)
{
this.ValidateUri(feed.NextPageLink);
base.VisitFeed(feed);
}
/// <summary>
/// Provide additional serialization information to the <see cref="ODataWriter"/> for <paramref name="feed"/>.
/// </summary>
/// <param name="feed">The instance to set the serialization info.</param>
/// <param name="serializationInfo">The serialization info to set.</param>
public static void SetSerializationInfo(this ODataFeed feed, ODataFeedAndEntrySerializationInfo serializationInfo)
{
ExceptionUtils.CheckArgumentNotNull(feed, "feed");
feed.SerializationInfo = serializationInfo;
}
/// <summary> /// Asynchronously start writing an expanded feed. /// </summary> /// <param name="expandedFeed">The expanded feed to write.</param> /// <returns>A task instance that represents the asynchronous write operation.</returns> public abstract Task WriteStartAsync(ODataFeed expandedFeed);
/// <summary> /// Start writing an expanded feed. /// </summary> /// <param name="expandedFeed">The expanded feed to write.</param> public abstract void WriteStart(ODataFeed expandedFeed);
/// <summary>
/// Validates an <see cref="ODataFeed"/> to ensure all required information is specified and valid on the WriteEnd call.
/// </summary>
/// <param name="feed">The feed to validate.</param>
/// <param name="writingRequest">Flag indicating whether the feed is written as part of a request or a response.</param>
internal static void ValidateFeedAtEnd(ODataFeed feed, bool writingRequest)
{
Debug.Assert(feed != null, "feed != null");
// Verify next link
if (feed.NextPageLink != null)
{
// Check that NextPageLink is not set for requests
if (writingRequest)
{
throw new ODataException(Strings.WriterValidationUtils_NextPageLinkInRequest);
}
}
}
public void WriteStartOnExpandedFeedWithDeltaLinkShouldIgnoreDeltaLink()
{
string expectedPayload =
@"<?xml version=""1.0"" encoding=""utf-8""?>"
+ @"<entry xmlns=""http://www.w3.org/2005/Atom"" xmlns:d=""http://docs.oasis-open.org/odata/ns/data"" xmlns:m=""http://docs.oasis-open.org/odata/ns/metadata"" xmlns:georss=""http://www.georss.org/georss"" xmlns:gml=""http://www.opengis.net/gml"" m:context=""http://www.example.com/$metadata#TestEntitySet/$entity"">"
+ @"<link rel=""http://docs.oasis-open.org/odata/ns/related/ResourceSetNavigationProperty"" type=""application/atom+xml;type=feed"" title=""ResourceSetNavigationProperty"" href=""http://host/navProp"">"
+"<m:inline><feed><id>http://host/TestEntitySet</id><title />";
Action<ODataWriter> deltaLinkAtWriteStart = (odataWriter) =>
{
var entryToWrite = new ODataEntry { Properties = new[] { new ODataProperty { Name = "ID", Value = 1 } } };
odataWriter.WriteStart(entryToWrite);
ODataNavigationLink navLink = new ODataNavigationLink { Name = "ResourceSetNavigationProperty", IsCollection = true, Url = new Uri("http://host/navProp") };
odataWriter.WriteStart(navLink);
var feedToWrite = new ODataFeed() { Id = new Uri("http://host/TestEntitySet", UriKind.Absolute) };
feedToWrite.DeltaLink = new Uri("http://host/relative", UriKind.Absolute);
odataWriter.WriteStart(feedToWrite);
};
WriteAnnotationsAndValidatePayload(deltaLinkAtWriteStart, ODataFormat.Atom, expectedPayload, request: true, createFeedWriter: false);
WriteAnnotationsAndValidatePayload(deltaLinkAtWriteStart, ODataFormat.Atom, expectedPayload, request: false, createFeedWriter: false);
}
/// <summary>
/// Tries to read a feed.
/// </summary>
/// <param name="lazy">if set to <c>true</c> [lazy].</param>
/// <param name="feed">The feed.</param>
/// <returns>true if a value was read, otherwise false</returns>
private bool TryReadFeed(bool lazy, out ODataFeed feed)
{
if (this.TryStartReadFeedOrEntry())
{
this.ExpectState(ODataReaderState.FeedStart);
feed = this.ReadFeedCore(lazy);
}
else
{
feed = null;
}
return feed != null;
}
/// <summary> Asynchronously start writing a feed. </summary> /// <returns>A task instance that represents the asynchronous write operation.</returns> /// <param name="feed">The feed or collection to write.</param> public abstract Task WriteStartAsync(ODataFeed feed);
public void WriteObjectInline_Writes_CreateODataFeedOutput()
{
// Arrange
IEnumerable instance = new object[0];
ODataFeed feed = new ODataFeed();
Mock<ODataFeedSerializer> serializer = new Mock<ODataFeedSerializer>(new DefaultODataSerializerProvider());
serializer.CallBase = true;
serializer.Setup(s => s.CreateODataFeed(instance, _customersType, _writeContext)).Returns(feed);
Mock<ODataWriter> writer = new Mock<ODataWriter>();
writer.Setup(s => s.WriteStart(feed)).Verifiable();
// Act
serializer.Object.WriteObjectInline(instance, _customersType, writer.Object, _writeContext);
// Assert
writer.Verify();
}
/// <summary>
/// Tries to read a feed or entry.
/// </summary>
/// <param name="lazy">if set to <c>true</c> [lazy].</param>
/// <param name="feed">The feed.</param>
/// <param name="entry">The entry.</param>
/// <returns>true if a value was read, otherwise false</returns>
private bool TryReadFeedOrEntry(bool lazy, out ODataFeed feed, out MaterializerEntry entry)
{
if (this.TryStartReadFeedOrEntry())
{
if (this.reader.State == ODataReaderState.EntryStart)
{
entry = this.ReadEntryCore();
feed = null;
}
else
{
entry = null;
feed = this.ReadFeedCore(lazy);
}
}
else
{
feed = null;
entry = null;
}
Debug.Assert(feed == null || entry == null, "feed == null || entry == null");
return feed != null || entry != null;
}
/// <summary>Starts the writing of a feed.</summary> /// <param name="feed">The feed or collection to write.</param> public abstract void WriteStart(ODataFeed feed);
/// <summary>
/// Validates an <see cref="ODataFeed"/> to ensure all required information is specified and valid on the WriteEnd call.
/// </summary>
/// <param name="feed">The feed to validate.</param>
/// <param name="writingRequest">Flag indicating whether the feed is written as part of a request or a response.</param>
public void ValidateFeedAtEnd(ODataFeed feed, bool writingRequest)
{
WriterValidationUtils.ValidateFeedAtEnd(feed, writingRequest);
}
private ODataFeedAnnotations CreateFeedAnnotaions(ODataFeed feed)
{
return new ODataFeedAnnotations()
{
Id = feed.Id == null ? null : feed.Id.AbsoluteUri,
Count = feed.Count,
DeltaLink = feed.DeltaLink,
NextPageLink = feed.NextPageLink,
InstanceAnnotations = feed.InstanceAnnotations,
};
}
