public void QueryWithFilterTime()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in mimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Orders?$filter=ShipTime eq 12:40:5.05", UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var reader = messageReader.CreateODataFeedReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
ODataEntry entry = reader.Item as ODataEntry;
// Verify Date Property
Assert.AreEqual(new Date(2014, 8, 31), entry.Properties.Single(p => p.Name == "ShipDate").Value);
Assert.AreEqual(new TimeOfDay(12, 40, 5, 50), entry.Properties.Single(p => p.Name == "ShipTime").Value);
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
}
}
}
public static IEnumerable <ODataEntry> ReadODataFeed(IEdmModel model, Stream stream)
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceRootUri
};
var responseMessage = new ODataResponseMessage(stream);
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, model))
{
List <ODataEntry> entries = new List <ODataEntry>();
var reader = messageReader.CreateODataFeedReader();
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.EntryEnd:
ODataEntry entry = reader.Item as ODataEntry;
entries.Add(entry);
yield return(entry);
break;
default:
break;
}
}
}
}
public void QueryEntitySet()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in mimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Customers", UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var reader = messageReader.CreateODataFeedReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
ODataEntry entry = reader.Item as ODataEntry;
Assert.IsNotNull(entry.Properties.Single(p => p.Name == "TimeBetweenLastTwoOrders").Value);
}
}
}
}
}
}
public List<ODataEntry> QueryFeed(string requestUri, string mimeType)
{
List<ODataEntry> entries = new List<ODataEntry>();
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings() { BaseUri = baseUri };
var requestMessage = new HttpWebRequestMessage(new Uri(baseUri.AbsoluteUri + requestUri, UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, model))
{
var reader = messageReader.CreateODataFeedReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
ODataEntry entry = reader.Item as ODataEntry;
entries.Add(entry);
}
else if (reader.State == ODataReaderState.FeedEnd)
{
Assert.IsNotNull(reader.Item as ODataFeed);
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
}
return entries;
}
/// <summary>
/// Creates an OData reader to read OData feed download response.
/// </summary>
/// <param name="reader">The message reader containing current OData feed download response.</param>
/// <returns>an OData reader to read OData feed download response</returns>
private ODataReader CreateReader(ODataMessageReader reader)
{
ODataReader resultReader = null;
resultReader = reader.CreateODataFeedReader();
return(resultReader);
}
public void QueryWithFormat()
{
Dictionary <string, string> testCases = new Dictionary <string, string>()
{
{ "People?$format=application/json", "application/json" },
// ODL Bug: https://github.com/OData/odata.net/issues/313
////{"People?$format=application/json;odata.metadata=full", "application/json; odata.metadata=full"},
{ "People?$format=json", "application/json" },
};
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri,
UndeclaredPropertyBehaviorKinds = ODataUndeclaredPropertyBehaviorKinds.IgnoreUndeclaredValueProperty
};
foreach (var testCase in testCases)
{
DataServiceClientRequestMessageArgs args = new DataServiceClientRequestMessageArgs(
"GET",
new Uri(ServiceBaseUri.AbsoluteUri + testCase.Key, UriKind.Absolute),
false, false, new Dictionary <string, string>()
{
});
var requestMessage = new HttpWebRequestMessage(args);
using (var responseMessage = requestMessage.GetResponse() as HttpWebResponseMessage)
{
Assert.Equal(200, responseMessage.StatusCode);
string contentType = responseMessage.Headers.FirstOrDefault(x => x.Key.Equals("Content-Type")).Value;
Assert.True(contentType.StartsWith(testCase.Value));
using (var messageReader = new ODataMessageReader(
responseMessage,
readerSettings,
this.TestClientContext.Format.LoadServiceModel()))
{
var reader = messageReader.CreateODataFeedReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
ODataEntry entry = reader.Item as ODataEntry;
Assert.NotNull(entry.Properties.Single(p => p.Name == "PersonId").Value);
}
else if (reader.State == ODataReaderState.FeedEnd)
{
Assert.NotNull(reader.Item as ODataFeed);
}
}
Assert.Equal(ODataReaderState.Completed, reader.State);
}
}
}
}
public async Task <ODataResponse> GetResponseAsync(IODataResponseMessageAsync responseMessage, bool includeResourceTypeInEntryProperties = false)
#endif
{
var readerSettings = new ODataMessageReaderSettings();
readerSettings.MessageQuotas.MaxReceivedMessageSize = Int32.MaxValue;
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, _model))
{
var payloadKind = messageReader.DetectPayloadKind();
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Error))
{
return(ODataResponse.FromStatusCode(responseMessage.StatusCode));
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Value))
{
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Collection))
{
throw new NotImplementedException();
}
else
{
#if SILVERLIGHT
var text = Utils.StreamToString(responseMessage.GetStream());
#else
var text = Client.Utils.StreamToString(await responseMessage.GetStreamAsync());
#endif
return(ODataResponse.FromFeed(new[] { new Dictionary <string, object>()
{
{ FluentCommand.ResultLiteral, text }
} }));
}
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Batch))
{
return(await ReadResponse(messageReader.CreateODataBatchReader(), includeResourceTypeInEntryProperties));
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Feed))
{
return(ReadResponse(messageReader.CreateODataFeedReader(), includeResourceTypeInEntryProperties));
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Collection))
{
return(ReadResponse(messageReader.CreateODataCollectionReader(), includeResourceTypeInEntryProperties));
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Property))
{
var property = messageReader.ReadProperty();
return(ODataResponse.FromFeed(new[] { new Dictionary <string, object>()
{
{ property.Name ?? FluentCommand.ResultLiteral, GetPropertyValue(property.Value) }
} }));
}
else
{
return(ReadResponse(messageReader.CreateODataEntryReader(), includeResourceTypeInEntryProperties));
}
}
}
private void CreateAndReadUnlimitedResponseMessageWithFeed(string startingString, string cycleString)
{
var responseMessage = new ODataUnlimitedResponseMessage(startingString, cycleString);
responseMessage.SetHeader("Content-Type", "application/atom+xml");
responseMessage.SetHeader("DataServiceVersion", "3.0");
var readLimitReached = false;
try
{
using (var messageReader = new ODataMessageReader(responseMessage))
{
var feedReader = messageReader.CreateODataFeedReader();
while (feedReader.Read())
{
switch (feedReader.State)
{
case ODataReaderState.FeedStart:
Console.WriteLine("FeedStart: " + (ODataFeed)feedReader.Item);
break;
case ODataReaderState.FeedEnd:
Console.WriteLine("FeedEnd: " + (ODataFeed)feedReader.Item);
break;
case ODataReaderState.EntryStart:
Console.WriteLine("EntryStart: " + (ODataEntry)feedReader.Item);
break;
case ODataReaderState.EntryEnd:
Console.WriteLine("EntryEnd: " + (ODataEntry)feedReader.Item);
break;
default:
Console.WriteLine("ODataItem: " + feedReader.Item);
break;
}
}
}
}
catch (ODataException ex)
{
if (ex.Message.StartsWith("The maximum number of bytes allowed to be read from the stream has been exceeded."))
{
readLimitReached = true;
}
else
{
throw;
}
}
if (!readLimitReached)
{
throw new InvalidOperationException("Expecting exception, but it was not thrown.");
}
}
public void QueryAvroFeed()
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Products", UriKind.Absolute));
requestMessage.SetHeader("Accept", "avro/binary");
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
IList <ODataEntry> entries = new List <ODataEntry>();
using (var messageReader = new ODataMessageReader(responseMessage, GetAvroReaderSettings(), Model))
{
var reader = messageReader.CreateODataFeedReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
entries.Add((ODataEntry)reader.Item);
}
}
}
Assert.AreEqual(3, entries.Count);
ODataEntry product2 = new ODataEntry
{
Properties = new[]
{
new ODataProperty {
Name = "Id", Value = 2
},
new ODataProperty {
Name = "Name", Value = "Banana"
},
new ODataProperty
{
Name = "Info",
Value = new ODataComplexValue()
{
Properties = new []
{
new ODataProperty {
Name = "Site", Value = "G2"
},
new ODataProperty {
Name = "Serial", Value = 1023L
},
}
}
},
},
};
Assert.IsTrue(TestHelper.EntryEqual(product2, entries[1]));
}
internal static ResultSegment <TElement> TableQueryPostProcessGeneric <TElement, TQueryType>(Stream responseStream, Func <string, string, DateTimeOffset, IDictionary <string, EntityProperty>, string, TElement> resolver, HttpWebResponse resp, TableRequestOptions options, OperationContext ctx, string accountName)
{
ResultSegment <TElement> retSeg = new ResultSegment <TElement>(new List <TElement>());
retSeg.ContinuationToken = ContinuationFromResponse(resp);
if (resp.ContentType.Contains(Constants.JsonNoMetadataAcceptHeaderValue))
{
ReadQueryResponseUsingJsonParser(retSeg, responseStream, resp.Headers[Constants.HeaderConstants.EtagHeader], resolver, options.PropertyResolver, typeof(TQueryType), null, options);
}
else
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings();
readerSettings.MessageQuotas = new ODataMessageQuotas()
{
MaxPartsPerBatch = TableConstants.TableServiceMaxResults, MaxReceivedMessageSize = TableConstants.TableServiceMaxPayload
};
using (ODataMessageReader responseReader = new ODataMessageReader(new HttpResponseAdapterMessage(resp, responseStream), readerSettings, new TableStorageModel(accountName)))
{
// create a reader
ODataReader reader = responseReader.CreateODataFeedReader();
// Start => FeedStart
if (reader.State == ODataReaderState.Start)
{
reader.Read();
}
// Feedstart
if (reader.State == ODataReaderState.FeedStart)
{
reader.Read();
}
while (reader.State == ODataReaderState.EntryStart)
{
// EntryStart => EntryEnd
reader.Read();
ODataEntry entry = (ODataEntry)reader.Item;
retSeg.Results.Add(ReadAndResolve(entry, resolver, options));
// Entry End => ?
reader.Read();
}
DrainODataReader(reader);
}
}
Logger.LogInformational(ctx, SR.RetrieveWithContinuationToken, retSeg.Results.Count, retSeg.ContinuationToken);
return(retSeg);
}
internal static Task <TableQuerySegment> TableQueryPostProcess(Stream responseStream, HttpResponseMessage resp, Exception ex, OperationContext ctx)
{
return(Task.Run(() =>
{
TableQuerySegment retSeg = new TableQuerySegment();
retSeg.ContinuationToken = ContinuationFromResponse(resp);
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
DisablePrimitiveTypeConversion = true
};
readerSettings.MessageQuotas = new ODataMessageQuotas()
{
MaxPartsPerBatch = TableConstants.TableServiceMaxResults, MaxReceivedMessageSize = TableConstants.TableServiceMaxPayload
};
using (ODataMessageReader responseReader = new ODataMessageReader(new HttpResponseAdapterMessage(resp, responseStream), readerSettings))
{
// create a reader
ODataReader reader = responseReader.CreateODataFeedReader();
// Start => FeedStart
if (reader.State == ODataReaderState.Start)
{
reader.Read();
}
// Feedstart
if (reader.State == ODataReaderState.FeedStart)
{
reader.Read();
}
while (reader.State == ODataReaderState.EntryStart)
{
// EntryStart => EntryEnd
reader.Read();
ODataEntry entry = (ODataEntry)reader.Item;
DynamicTableEntity retEntity = new DynamicTableEntity();
ReadAndUpdateTableEntity(retEntity, entry, EntityReadFlags.All, ctx);
retSeg.Results.Add(retEntity);
// Entry End => ?
reader.Read();
}
DrainODataReader(reader);
}
return retSeg;
}));
}
/// <summary>
/// Read the response message and perform given verifications
/// </summary>
/// <param name="isFeed">Whether the response has a feed</param>
/// <param name="responseMessage">The response message</param>
/// <param name="expectedSet">Expected IEdmEntitySet</param>
/// <param name="expectedType">Expected IEdmEntityType</param>
/// <param name="verifyFeed">Action to verify the feed</param>
/// <param name="verifyEntry">Action to verify the entry</param>
/// <param name="verifyNavigation">Action to verify the navigation</param>
public static void ReadAndVerifyFeedEntryMessage(bool isFeed, StreamResponseMessage responseMessage,
IEdmEntitySet expectedSet, IEdmEntityType expectedType,
Action <ODataFeed> verifyFeed, Action <ODataEntry> verifyEntry,
Action <ODataNavigationLink> verifyNavigation)
{
var settings = new ODataMessageReaderSettings()
{
BaseUri = ServiceUri
};
settings.ShouldIncludeAnnotation = s => true;
ODataMessageReader messageReader = new ODataMessageReader(responseMessage, settings, Model);
ODataReader reader = isFeed
? messageReader.CreateODataFeedReader(expectedSet, expectedType)
: messageReader.CreateODataEntryReader(expectedSet, expectedType);
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.FeedEnd:
{
if (verifyFeed != null)
{
verifyFeed((ODataFeed)reader.Item);
}
break;
}
case ODataReaderState.EntryEnd:
{
if (verifyEntry != null)
{
verifyEntry((ODataEntry)reader.Item);
}
break;
}
case ODataReaderState.NavigationLinkEnd:
{
if (verifyNavigation != null)
{
verifyNavigation((ODataNavigationLink)reader.Item);
}
break;
}
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
/// <summary>
/// Creates and Wraps an ODataReader for feeds or entries.
/// </summary>
/// <param name="messageReader">The message reader.</param>
/// <param name="messageType">The message type.</param>
/// <param name="expectedType">The expected EDM type.</param>
/// <param name="responsePipeline">The data service response pipeling configuration object.</param>
/// <returns>A reader.</returns>
internal static ODataReaderWrapper Create(ODataMessageReader messageReader, ODataPayloadKind messageType, IEdmType expectedType, DataServiceClientResponsePipelineConfiguration responsePipeline)
{
IEdmEntityType entityType = expectedType as IEdmEntityType;
if (messageType == ODataPayloadKind.Entry)
{
return(new ODataReaderWrapper(messageReader.CreateODataEntryReader(entityType), responsePipeline));
}
return(new ODataReaderWrapper(messageReader.CreateODataFeedReader(entityType), responsePipeline));
}
public async Task<ODataResponse> GetResponseAsync(IODataResponseMessageAsync responseMessage, bool includeResourceTypeInEntryProperties = false)
{
var readerSettings = new ODataMessageReaderSettings();
readerSettings.MessageQuotas.MaxReceivedMessageSize = Int32.MaxValue;
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, _model))
{
var payloadKind = messageReader.DetectPayloadKind();
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Error))
{
return ODataResponse.FromStatusCode(responseMessage.StatusCode);
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Value))
{
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Collection))
{
throw new NotImplementedException();
}
else
{
var text = Utils.StreamToString(await responseMessage.GetStreamAsync());
return ODataResponse.FromFeed(new[] { new Dictionary<string, object>()
{
{ FluentCommand.ResultLiteral, text }
} });
}
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Batch))
{
return await ReadResponse(messageReader.CreateODataBatchReader(), includeResourceTypeInEntryProperties);
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Feed))
{
return ReadResponse(messageReader.CreateODataFeedReader(), includeResourceTypeInEntryProperties);
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Collection))
{
return ReadResponse(messageReader.CreateODataCollectionReader(), includeResourceTypeInEntryProperties);
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Property))
{
var property = messageReader.ReadProperty();
return ODataResponse.FromFeed(new[] { new Dictionary<string, object>()
{
{ property.Name ?? FluentCommand.ResultLiteral, GetPropertyValue(property.Value) }
} });
}
else
{
return ReadResponse(messageReader.CreateODataEntryReader(), includeResourceTypeInEntryProperties);
}
}
}
public void TestCreateODataFeedReader_InJsonLight_WithoutEntitySetOrType_Throws()
{
// Arrange
IODataRequestMessage request = CreateJsonLightRequest();
ODataMessageReaderSettings settings = CreateSettings();
IEdmModel model = CreateModel();
using (ODataMessageReader reader = new ODataMessageReader(request, settings, model))
{
// Act & Assert
Assert.Throws <ODataException>(() => reader.CreateODataFeedReader());
}
}
public void QueryWithSelect()
{
Dictionary <string, int> testCases = new Dictionary <string, int>()
{
{ "Customers?$select=PersonID,FirstName", 2 },
{ "Customers?$select=*", 12 },
};
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var testCase in testCases)
{
foreach (var mimeType in mimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + testCase.Key, UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var reader = messageReader.CreateODataFeedReader();
int count = 0;
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
ODataEntry entry = reader.Item as ODataEntry;
Assert.IsNotNull(entry.Properties.Single(p => p.Name == "PersonID").Value);
Assert.IsNotNull(entry.Properties.Single(p => p.Name == "FirstName").Value);
Assert.AreEqual(testCase.Value, entry.Properties.Count());
count++;
}
else if (reader.State == ODataReaderState.FeedEnd)
{
Assert.IsNotNull(reader.Item as ODataFeed);
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
Assert.IsTrue(count > 0, "No entry is returned.");
}
}
}
}
}
public async Task <ODataResponse> GetResponseAsync(IODataResponseMessageAsync responseMessage)
{
var readerSettings = new ODataMessageReaderSettings();
if (_session.Settings.IgnoreUnmappedProperties)
{
readerSettings.UndeclaredPropertyBehaviorKinds = ODataUndeclaredPropertyBehaviorKinds.IgnoreUndeclaredValueProperty;
}
readerSettings.MessageQuotas.MaxReceivedMessageSize = Int32.MaxValue;
readerSettings.ShouldIncludeAnnotation = x => _session.Settings.IncludeAnnotationsInResults;
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, _model))
{
var payloadKind = messageReader.DetectPayloadKind();
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Error))
{
return(ODataResponse.FromStatusCode(responseMessage.StatusCode));
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Value))
{
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Collection))
{
throw new NotImplementedException();
}
else
{
return(ODataResponse.FromValueStream(await responseMessage.GetStreamAsync().ConfigureAwait(false), responseMessage is ODataBatchOperationResponseMessage));
}
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Batch))
{
return(await ReadResponse(messageReader.CreateODataBatchReader()).ConfigureAwait(false));
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Feed))
{
return(ReadResponse(messageReader.CreateODataFeedReader()));
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Collection))
{
return(ReadResponse(messageReader.CreateODataCollectionReader()));
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Property))
{
var property = messageReader.ReadProperty();
return(ODataResponse.FromProperty(property.Name, GetPropertyValue(property.Value)));
}
else
{
return(ReadResponse(messageReader.CreateODataEntryReader()));
}
}
}
protected static ODataReader CreateODataReader(ODataMessageReader messageReader, ODataPayloadKind messageType, IEdmType expectedType, DataServiceProtocolVersion protocolVersion)
{
if (expectedType != null)
{
ClientEdmModel.GetModel(protocolVersion).GetClientTypeAnnotation(expectedType).EnsureEPMLoaded();
}
IEdmEntityType expectedEntityType = expectedType as IEdmEntityType;
if (messageType == ODataPayloadKind.Entry)
{
return(messageReader.CreateODataEntryReader(expectedEntityType));
}
return(messageReader.CreateODataFeedReader(expectedEntityType));
}
public void TestCreateODataFeedReader_InJsonLight_WithEntityTypeButWithoutSet_Throws()
{
// Arrange
IODataRequestMessage request = CreateJsonLightRequest();
ODataMessageReaderSettings settings = CreateSettings();
IEdmModel model = CreateModel();
IEdmEntityType entityType = model.EntityContainer.EntitySets().First().EntityType();
using (ODataMessageReader reader = new ODataMessageReader(request, settings, model))
{
// Act & Assert
Assert.Throws <ODataException>(() => reader.CreateODataFeedReader(entityType));
}
}
public void TestCreateODataFeedReader_InJsonLight_WithEntitySetButWithoutType_DoesNotThrow()
{
// Arrange
IODataRequestMessage request = CreateJsonLightRequest();
ODataMessageReaderSettings settings = CreateSettings();
IEdmModel model = CreateModel();
IEdmEntitySet entitySet = model.EntityContainer.EntitySets().First();
using (ODataMessageReader reader = new ODataMessageReader(request, settings, model))
{
// Act & Assert
Assert.DoesNotThrow(() => reader.CreateODataFeedReader(entitySet, null));
}
}
private void PrimitiveValueInFilterInURL(string filterQuery)
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = this.ServiceUri
};
foreach (var mimeType in mimeTypes)
{
var requestMessage = new Microsoft.Test.OData.Tests.Client.Common.HttpWebRequestMessage(new Uri(this.ServiceUri.AbsoluteUri + filterQuery, UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, RetrieveServiceEdmModel()))
{
var reader = messageReader.CreateODataFeedReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
string pattern = filterQuery.Substring(0, filterQuery.IndexOf("?")) + @"\(" + dataPattern + @"\)$";
Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
ODataEntry entry = reader.Item as ODataEntry;
Assert.IsTrue(rgx.Match(entry.Id.ToString()).Success, "Expected : Entry's Id doesn't contain trailing when Key is Int64/float/double/decimal");
if (mimeType.Equals(MimeTypes.ApplicationJson + MimeTypes.ODataParameterFullMetadata))
{
Assert.IsTrue(rgx.Match(entry.EditLink.ToString()).Success, "Expected : Entry's EditLink doesn't contain trailing when Key is Int64/float/double/decimal");
Assert.IsTrue(rgx.Match(entry.ReadLink.ToString()).Success, "Expected : Entry's ReadLink doesn't contain trailing when Key is Int64/float/double/decimal");
}
}
else if (reader.State == ODataReaderState.FeedEnd)
{
//TODO: Nextlink is appened by data service. So whether L|F|D|M could be returned in nextLink
var pattern = filterQuery.Substring(0, filterQuery.IndexOf("?")) + @"\?\$filter=Id\sge\s" + dataPattern + @"(L|F|D|M)?&\$skiptoken=\d+$";
Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
ODataFeed feed = reader.Item as ODataFeed;
Assert.IsTrue(rgx.Match(feed.NextPageLink.ToString()).Success, "Expected : Feed's NextLink doesn't contain trailing when Key is Int64/float/double/decimal");
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
}
}
}
internal static Task <ResultSegment <TElement> > TableQueryPostProcessGeneric <TElement>(Stream responseStream, Func <string, string, DateTimeOffset, IDictionary <string, EntityProperty>, string, TElement> resolver, HttpResponseMessage resp, OperationContext ctx)
{
return(Task.Run(() =>
{
ResultSegment <TElement> retSeg = new ResultSegment <TElement>(new List <TElement>());
retSeg.ContinuationToken = ContinuationFromResponse(resp);
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings();
readerSettings.MessageQuotas = new ODataMessageQuotas()
{
MaxPartsPerBatch = TableConstants.TableServiceMaxResults, MaxReceivedMessageSize = TableConstants.TableServiceMaxPayload
};
using (ODataMessageReader responseReader = new ODataMessageReader(new HttpResponseAdapterMessage(resp, responseStream), readerSettings))
{
// create a reader
ODataReader reader = responseReader.CreateODataFeedReader();
// Start => FeedStart
if (reader.State == ODataReaderState.Start)
{
reader.Read();
}
// Feedstart
if (reader.State == ODataReaderState.FeedStart)
{
reader.Read();
}
while (reader.State == ODataReaderState.EntryStart)
{
// EntryStart => EntryEnd
reader.Read();
ODataEntry entry = (ODataEntry)reader.Item;
retSeg.Results.Add(ReadAndResolve(entry, resolver));
// Entry End => ?
reader.Read();
}
DrainODataReader(reader);
}
return retSeg;
}));
}
/// <summary>
/// Read the response message and perform given verifications
/// </summary>
/// <param name="isFeed">Whether the response has a feed</param>
/// <param name="responseMessage">The response message</param>
/// <param name="expectedSet">Expected IEdmEntitySet</param>
/// <param name="expectedType">Expected IEdmEntityType</param>
/// <param name="verifyFeed">Action to verify the feed</param>
/// <param name="verifyEntry">Action to verify the entry</param>
/// <param name="verifyNavigation">Action to verify the navigation</param>
public static void ReadAndVerifyFeedEntryMessage(bool isFeed, StreamResponseMessage responseMessage,
IEdmEntitySet expectedSet, IEdmEntityType expectedType,
Action<ODataFeed> verifyFeed, Action<ODataEntry> verifyEntry,
Action<ODataNavigationLink> verifyNavigation)
{
var settings = new ODataMessageReaderSettings() { BaseUri = ServiceUri };
settings.ShouldIncludeAnnotation = s => true;
ODataMessageReader messageReader = new ODataMessageReader(responseMessage, settings, Model);
ODataReader reader = isFeed
? messageReader.CreateODataFeedReader(expectedSet, expectedType)
: messageReader.CreateODataEntryReader(expectedSet, expectedType);
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.FeedEnd:
{
if (verifyFeed != null)
{
verifyFeed((ODataFeed)reader.Item);
}
break;
}
case ODataReaderState.EntryEnd:
{
if (verifyEntry != null)
{
verifyEntry((ODataEntry)reader.Item);
}
break;
}
case ODataReaderState.NavigationLinkEnd:
{
if (verifyNavigation != null)
{
verifyNavigation((ODataNavigationLink)reader.Item);
}
break;
}
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
internal static object ConvertFeed(ODataMessageReader oDataMessageReader, IEdmTypeReference edmTypeReference, ODataDeserializerContext readContext)
{
IEdmCollectionTypeReference collectionType = edmTypeReference.AsCollection();
EdmEntitySet tempEntitySet = new EdmEntitySet(readContext.Model.EntityContainer, "temp",
collectionType.ElementType().AsEntity().EntityDefinition());
ODataReader odataReader = oDataMessageReader.CreateODataFeedReader(tempEntitySet,
collectionType.ElementType().AsEntity().EntityDefinition());
ODataFeedWithEntries feed =
ODataEntityDeserializer.ReadEntryOrFeed(odataReader) as ODataFeedWithEntries;
ODataFeedDeserializer feedDeserializer =
(ODataFeedDeserializer)DeserializerProvider.GetEdmTypeDeserializer(collectionType);
object result = feedDeserializer.ReadInline(feed, collectionType, readContext);
IEnumerable enumerable = result as IEnumerable;
if (enumerable != null)
{
IEnumerable newEnumerable = CovertFeedIds(enumerable, feed, collectionType, readContext);
if (readContext.IsUntyped)
{
EdmEntityObjectCollection entityCollection =
new EdmEntityObjectCollection(collectionType);
foreach (EdmEntityObject entity in newEnumerable)
{
entityCollection.Add(entity);
}
return(entityCollection);
}
else
{
IEdmTypeReference elementTypeReference = collectionType.ElementType();
Type elementClrType = EdmLibHelpers.GetClrType(elementTypeReference,
readContext.Model);
IEnumerable castedResult =
CastMethodInfo.MakeGenericMethod(elementClrType)
.Invoke(null, new object[] { newEnumerable }) as IEnumerable;
return(castedResult);
}
}
return(null);
}
public void QueryEntitySet()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in mimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Products", UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
List <ODataEntry> entries = new List <ODataEntry>();
var reader = messageReader.CreateODataFeedReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
ODataEntry entry = reader.Item as ODataEntry;
Assert.IsNotNull(entry);
entries.Add(entry);
}
else if (reader.State == ODataReaderState.FeedEnd)
{
Assert.IsNotNull(reader.Item as ODataFeed);
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
Assert.AreEqual(5, entries.Count);
ODataEnumValue skinColor = (ODataEnumValue)entries[1].Properties.Single(p => p.Name == "SkinColor").Value;
ODataEnumValue userAccess = (ODataEnumValue)entries[1].Properties.Single(p => p.Name == "UserAccess").Value;
Assert.AreEqual("Blue", skinColor.Value);
Assert.AreEqual("ReadWrite", userAccess.Value);
}
}
}
}
public override object Read(ODataMessageReader messageReader, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
if (readContext == null)
{
throw Error.ArgumentNull("readContext");
}
ODataReader reader = messageReader.CreateODataFeedReader(_edmEntityType.EntityDefinition());
ODataFeed feed = ODataEntityDeserializer.ReadEntryOrFeed(reader, readContext) as ODataFeed;
return(ReadInline(feed, readContext));
}
public async Task <ODataResponse> GetResponseAsync(IODataResponseMessageAsync responseMessage)
{
var readerSettings = new ODataMessageReaderSettings();
readerSettings.MessageQuotas.MaxReceivedMessageSize = Int32.MaxValue;
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, _model))
{
var payloadKind = messageReader.DetectPayloadKind();
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Error))
{
return(ODataResponse.FromStatusCode(responseMessage.StatusCode));
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Value))
{
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Collection))
{
throw new NotImplementedException();
}
else
{
return(ODataResponse.FromValueStream(await responseMessage.GetStreamAsync()));
}
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Batch))
{
return(await ReadResponse(messageReader.CreateODataBatchReader()));
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Feed))
{
return(ReadResponse(messageReader.CreateODataFeedReader()));
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Collection))
{
return(ReadResponse(messageReader.CreateODataCollectionReader()));
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Property))
{
var property = messageReader.ReadProperty();
return(ODataResponse.FromProperty(property.Name, GetPropertyValue(property.Value)));
}
else
{
return(ReadResponse(messageReader.CreateODataEntryReader()));
}
}
}
public void QueryWithFormat()
{
Dictionary <string, string> testCases = new Dictionary <string, string>()
{
//{"Customers?$format=application/atom%2Bxml", "application/atom+xml"},
{ "Customers?$format=application/json", "application/json" },
{ "Customers?$format=application/json;odata.metadata=full", "application/json;odata.metadata=full" },
{ "Customers?$format=json", "application/json" },
};
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var testCase in testCases)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + testCase.Key, UriKind.Absolute));
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
string contentType = responseMessage.Headers.FirstOrDefault(x => x.Key.Equals("Content-Type")).Value;
Assert.IsTrue(contentType.StartsWith(testCase.Value));
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var reader = messageReader.CreateODataFeedReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
ODataEntry entry = reader.Item as ODataEntry;
Assert.IsNotNull(entry.Properties.Single(p => p.Name == "PersonID").Value);
}
else if (reader.State == ODataReaderState.FeedEnd)
{
Assert.IsNotNull(reader.Item as ODataFeed);
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
}
}
private void ReadFeedPayload(string payload, Action <ODataReader> action, bool isResponse = true, ODataVersion maxProtocolVersion = ODataVersion.V4)
{
if (isResponse)
{
IODataResponseMessage message = new InMemoryMessage()
{
Stream = new MemoryStream(Encoding.UTF8.GetBytes(payload)), StatusCode = 200
};
message.SetHeader("Content-Type", "application/atom+xml;type=feed");
ODataMessageReaderSettings settings = new ODataMessageReaderSettings()
{
MaxProtocolVersion = maxProtocolVersion,
EnableAtom = true
};
using (var msgReader = new ODataMessageReader(message, settings))
{
var reader = msgReader.CreateODataFeedReader();
while (reader.Read())
{
action(reader);
}
}
}
else
{
IODataRequestMessage message = new InMemoryMessage()
{
Stream = new MemoryStream(Encoding.UTF8.GetBytes(payload)), Method = "GET"
};
message.SetHeader("Content-Type", "application/atom+xml;type=feed");
ODataMessageReaderSettings settings = new ODataMessageReaderSettings()
{
MaxProtocolVersion = maxProtocolVersion,
EnableAtom = true
};
using (var msgReader = new ODataMessageReader(message, settings))
{
var reader = msgReader.CreateODataFeedReader();
while (reader.Read())
{
action(reader);
}
}
}
}
private static ODataResult GetODataResult(ODataMessageReader messageReader)
{
List <ODataPayloadKindDetectionResult> payloadKinds = messageReader.DetectPayloadKind().ToList();
if (payloadKinds.Count > 0)
{
switch (payloadKinds[0].PayloadKind)
{
case ODataPayloadKind.Feed:
return(new FeedODataResult(messageReader.CreateODataFeedReader()));
case ODataPayloadKind.Entry:
return(new FeedODataResult(messageReader.CreateODataEntryReader()));
}
throw new InvalidOperationException("unsupported payload kind " + payloadKinds[0].PayloadKind);
}
throw new InvalidOperationException("unknown payload kind");
}
private void ReadFeedPayload(string payload, Action <ODataReader> action)
{
var message = new InMemoryMessage()
{
Stream = new MemoryStream(Encoding.UTF8.GetBytes(payload))
};
message.SetHeader("Content-Type", "application/atom+xml;type=feed");
message.PreferenceAppliedHeader().AnnotationFilter = "*";
using (var msgReader = new ODataMessageReader((IODataResponseMessage)message, atomReaderSettings))
{
var reader = msgReader.CreateODataFeedReader();
while (reader.Read())
{
action(reader);
}
}
}
public void QueryEntitiesOrderByEnumProperty()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in mimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Products?$orderby=SkinColor", UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
List <ODataEntry> entries = new List <ODataEntry>();
var reader = messageReader.CreateODataFeedReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
ODataEntry entry = reader.Item as ODataEntry;
Assert.IsNotNull(entry);
entries.Add(entry);
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
Assert.AreEqual(5, entries.Count);
Assert.AreEqual(5, entries[0].Properties.Single(p => p.Name == "ProductID").Value);
Assert.AreEqual(7, entries[1].Properties.Single(p => p.Name == "ProductID").Value);
Assert.AreEqual(8, entries[2].Properties.Single(p => p.Name == "ProductID").Value);
Assert.AreEqual(9, entries[3].Properties.Single(p => p.Name == "ProductID").Value);
Assert.AreEqual(6, entries[4].Properties.Single(p => p.Name == "ProductID").Value);
}
}
}
}
public void ModelReferneceWithFilterOption()
{
Dictionary <string, int> testCases = new Dictionary <string, int>()
{
{ "VehicleGPSSet?$filter=VehicleSpeed gt 90", 3 },
{ "DerivedVehicleGPSSet?$filter=DisplayName eq 'DisplayName4'", 1 },
};
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var testCase in testCases)
{
foreach (var mimeType in mimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + testCase.Key, UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
List <ODataEntry> entries = new List <ODataEntry>();
var reader = messageReader.CreateODataFeedReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
entries.Add(reader.Item as ODataEntry);
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
Assert.AreEqual(testCase.Value, entries.Count);
}
}
}
}
}
public static List<CustomInstanceAnnotationsDescriptor> ReadFeedOrEntry(bool isFeed, Uri uri, string contentType, ODataMessageReaderSettings readerSettings, IEdmModel model)
{
var annotationsStack = new Stack<CustomInstanceAnnotationsDescriptor>();
var allAnnotations = new List<CustomInstanceAnnotationsDescriptor>();
var responseMessage = GetResponseMessge(uri, contentType);
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, model))
{
var reader = isFeed ? messageReader.CreateODataFeedReader() : messageReader.CreateODataEntryReader();
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.FeedStart:
case ODataReaderState.EntryStart:
{
var instanceAnnotations = GetItemInstanceAnnotations(reader);
var parent = annotationsStack.Count == 0 ? null : annotationsStack.Peek();
var current = new CustomInstanceAnnotationsDescriptor { TypeOfAnnotatedItem = reader.Item.GetType(), Parent = parent, AnnotationsOnStart = instanceAnnotations };
annotationsStack.Push(current);
allAnnotations.Add(current);
break;
}
case ODataReaderState.FeedEnd:
case ODataReaderState.EntryEnd:
{
var instanceAnnotations = GetItemInstanceAnnotations(reader);
var current = annotationsStack.Pop();
current.AnnotationsOnEnd = instanceAnnotations;
break;
}
}
}
}
return allAnnotations;
}
public async Task<ODataResponse> GetResponseAsync(IODataResponseMessageAsync responseMessage)
#endif
{
var readerSettings = new ODataMessageReaderSettings();
readerSettings.MessageQuotas.MaxReceivedMessageSize = Int32.MaxValue;
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, _model))
{
var payloadKind = messageReader.DetectPayloadKind();
if (payloadKind.Any(x => x.PayloadKind != ODataPayloadKind.Property))
_hasResponse = true;
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Error))
{
return ODataResponse.FromStatusCode(responseMessage.StatusCode);
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Value))
{
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Collection))
{
throw new NotImplementedException();
}
else
{
#if SILVERLIGHT
var stream = responseMessage.GetStream();
#else
var stream = await responseMessage.GetStreamAsync();
#endif
return ODataResponse.FromValueStream(stream);
}
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Batch))
{
return await ReadResponse(messageReader.CreateODataBatchReader());
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Feed))
{
return ReadResponse(messageReader.CreateODataFeedReader());
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Collection))
{
return ReadResponse(messageReader.CreateODataCollectionReader());
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Property))
{
var property = messageReader.ReadProperty();
if (property.Value != null && (property.Value.GetType() != typeof(string) || !string.IsNullOrEmpty(property.Value.ToString())))
_hasResponse = true;
if (_hasResponse)
{
return ODataResponse.FromProperty(property.Name, GetPropertyValue(property.Value));
}
else
{
return ODataResponse.EmptyFeed;
}
}
else
{
return ReadResponse(messageReader.CreateODataEntryReader());
}
}
}
public async Task<ODataResponse> GetResponseAsync(IODataResponseMessageAsync responseMessage)
{
var readerSettings = new ODataMessageReaderSettings();
readerSettings.MessageQuotas.MaxReceivedMessageSize = Int32.MaxValue;
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, _model))
{
var payloadKind = messageReader.DetectPayloadKind();
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Error))
{
return ODataResponse.FromStatusCode(responseMessage.StatusCode);
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Value))
{
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Collection))
{
throw new NotImplementedException();
}
else
{
return ODataResponse.FromValueStream(await responseMessage.GetStreamAsync());
}
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Batch))
{
return await ReadResponse(messageReader.CreateODataBatchReader());
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Feed))
{
return ReadResponse(messageReader.CreateODataFeedReader());
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Collection))
{
return ReadResponse(messageReader.CreateODataCollectionReader());
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Property))
{
var property = messageReader.ReadProperty();
return ODataResponse.FromProperty(property.Name, GetPropertyValue(property.Value));
}
else
{
return ReadResponse(messageReader.CreateODataEntryReader());
}
}
}
public void ReadFeedWithActionAndFunctionTest()
{
string payload = "{\"" +
"@odata.context\":\"http://example.org/odata.svc/$metadata#EntitySet\"," +
"\"#Namespace.Action\":{" +
"\"title\":\"ActionTitle\"," +
"\"target\":\"http://example.org/odata.svc/DoAction\"" +
"}," +
"\"#Namespace.Function\":{" +
"\"title\":\"FunctionTitle\"," +
"\"target\":\"http://example.org/odata.svc/DoFunction\"" +
"}," +
"\"value\":[" +
"{" +
"\"ID\":101,\"Name\":\"Alice\"" +
"}" +
"]" +
"}";
InMemoryMessage message = new InMemoryMessage();
message.SetHeader("Content-Type", "application/json;odata.metadata=minimal");
message.Stream = new MemoryStream(Encoding.UTF8.GetBytes(payload));
List<ODataFeed> feedList = new List<ODataFeed>();
using (var messageReader = new ODataMessageReader((IODataResponseMessage)message, null, ModelWithFunction))
{
messageReader.DetectPayloadKind().Single().PayloadKind.Should().Be(ODataPayloadKind.Feed);
var reader = messageReader.CreateODataFeedReader();
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.FeedEnd:
feedList.Add(reader.Item as ODataFeed);
break;
}
}
}
ODataFeed feed = feedList[0];
feed.Actions.Count().Should().Be(1);
feed.Functions.Count().Should().Be(1);
}
public void ReadingNestedInlinecountTest()
{
string payload = "{" +
"\"@odata.context\":\"http://example.org/odata.svc/$metadata#EntitySet\"," +
"\"value\":[" +
"{" +
"\"ID\":101,\"Name\":\"Alice\"," +
"\"[email protected]\":\"http://example.org/odata.svc/$metadata#EntitySet(101)/ContainedCollectionNavProp\"," +
"\"[email protected]\":\"http://example.org/odata.svc/navigation\"," +
"\"[email protected]\":1900," +
"\"ContainedCollectionNavProp\":[]" +
"}" +
"]" +
"}";
InMemoryMessage message = new InMemoryMessage();
message.SetHeader("Content-Type", "application/json;odata.metadata=minimal");
message.Stream = new MemoryStream(Encoding.UTF8.GetBytes(payload));
List<ODataFeed> feedList = new List<ODataFeed>();
using (var messageReader = new ODataMessageReader((IODataResponseMessage)message, null, Model))
{
var reader = messageReader.CreateODataFeedReader();
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.FeedEnd:
feedList.Add(reader.Item as ODataFeed);
break;
}
}
}
ODataFeed innerFeed = feedList[0];
innerFeed.Count.Should().Be(1900);
ODataFeed topFeed = feedList[1];
topFeed.Count.Should().Be(null);
}
public void ReadingInMinialMetadataModeWithContainedElementShouldBeAbleToGenerateId()
{
const string payload =
"{" +
"\"@odata.context\":\"http://example.com/$metadata#EntitySet(ContainedNavProp2,ExpandedNavLink,ExpandedNavLink(ContainedNavProp2))\"," +
"\"value\":[" +
"{" +
"\"[email protected]\":\"http://example.com/$metadata#EntitySet(123)/ContainedNonCollectionNavProp/$entity\"," +
"\"ContainedNonCollectionNavProp\":" +
"{" +
"\"ID\": 234," +
"\"Name\":\"Foo\"" +
"}," +
"\"ID\" : 123," +
"\"Name\" : \"Bob\"" +
"} ] }";
InMemoryMessage message = new InMemoryMessage();
message.SetHeader("Content-Type", "application/json;odata.metadata=mini");
message.Stream = new MemoryStream(Encoding.UTF8.GetBytes(payload));
ODataEntry topLevelEntry = null;
List<ODataEntry> entryList = new List<ODataEntry>();
using (var messageReader = new ODataMessageReader((IODataResponseMessage)message, null, Model))
{
var reader = messageReader.CreateODataFeedReader(EntitySet, EntityType);
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.EntryEnd:
topLevelEntry = (ODataEntry)reader.Item;
entryList.Add(topLevelEntry);
break;
}
}
}
Uri containedId = new Uri("http://example.com/EntitySet(123)/ContainedNonCollectionNavProp");
ODataEntry containedEntry = entryList[0];
containedEntry.Id.Should().Be(containedId);
}
public void TestCreateODataFeedReader_InJsonLight_WithoutEntitySetOrType_Throws()
{
// Arrange
IODataRequestMessage request = CreateJsonLightRequest();
ODataMessageReaderSettings settings = CreateSettings();
IEdmModel model = CreateModel();
using (ODataMessageReader reader = new ODataMessageReader(request, settings, model))
{
// Act & Assert
Assert.Throws<ODataException>(() => reader.CreateODataFeedReader());
}
}
/// <summary>
/// Creates and Wraps an ODataReader for feeds or entries.
/// </summary>
/// <param name="messageReader">The message reader.</param>
/// <param name="messageType">The message type.</param>
/// <param name="expectedType">The expected EDM type.</param>
/// <param name="responsePipeline">The data service response pipeling configuration object.</param>
/// <returns>A reader.</returns>
internal static ODataReaderWrapper Create(ODataMessageReader messageReader, ODataPayloadKind messageType, IEdmType expectedType, DataServiceClientResponsePipelineConfiguration responsePipeline)
{
IEdmEntityType entityType = expectedType as IEdmEntityType;
if (messageType == ODataPayloadKind.Entry)
{
return new ODataReaderWrapper(messageReader.CreateODataEntryReader(entityType), responsePipeline);
}
return new ODataReaderWrapper(messageReader.CreateODataFeedReader(entityType), responsePipeline);
}
public void ReadingInMinialMetadataModeWithContainedEntitySetShouldBeAbleToGenerateId()
{
const string payload =
"{" +
"\"@odata.context\":\"http://example.com/$metadata#EntitySet(1)/ContainedNavProp(ID)\"," +
"\"value\":[" +
"{" +
"\"ID\" : 123" +
"}" +
"] }";
InMemoryMessage message = new InMemoryMessage();
message.SetHeader("Content-Type", "application/json;odata.metadata=minimal");
message.Stream = new MemoryStream(Encoding.UTF8.GetBytes(payload));
ODataEntry topLevelEntry = null;
List<ODataEntry> entryList = new List<ODataEntry>();
using (var messageReader = new ODataMessageReader((IODataResponseMessage)message, null, Model))
{
var navProp = EntityType.FindProperty("ContainedNavProp") as IEdmNavigationProperty;
var containedEntitySet = EntitySet.FindNavigationTarget(navProp) as IEdmEntitySetBase;
var reader = messageReader.CreateODataFeedReader(containedEntitySet, EntityType);
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.EntryEnd:
topLevelEntry = (ODataEntry)reader.Item;
entryList.Add(topLevelEntry);
break;
}
}
}
Uri containedId = new Uri("http://example.com/EntitySet(1)/ContainedNavProp(123)");
ODataEntry containedEntry = entryList[0];
containedEntry.Id.Should().Be(containedId);
}
public static void FeedWriteReadNormal()
{
Console.WriteLine("FeedWriteReadNormal");
ODataFeed Feed = new ODataFeed();
Feed.SetSerializationInfo(new ODataFeedAndEntrySerializationInfo()
{
NavigationSourceName = "Mails",
NavigationSourceEntityTypeName = "NS.Mail",
NavigationSourceKind = EdmNavigationSourceKind.ContainedEntitySet
});
ODataEntry Entry = new ODataEntry()
{
Properties = new[]
{
new ODataProperty() {Name = "Id", Value = 2},
},
EditLink = new Uri("http://example/Web/Users(3)"),
};
Entry.SetSerializationInfo(new ODataFeedAndEntrySerializationInfo()
{
NavigationSourceName = "MyLogin",
NavigationSourceEntityTypeName = "NS.Person",
NavigationSourceKind = EdmNavigationSourceKind.ContainedEntitySet
});
// Parse the full request Uri
ODataPath path = new ODataUriParser(
CraftModel.Model,
new Uri("http://example.org/svc/"),
new Uri("http://example.org/svc/MyLogin/Mails")).ParsePath();
// Alternatively, construct the normal path for the contained entity manually.
//ODataPath path = new ODataPath(
// new ODataPathSegment[]
// {
// new SingletonSegment(CraftModel.MyLogin), new NavigationPropertySegment(CraftModel.MailBox, CraftModel.MyLogin)
// });
var stream = new MemoryStream();
var wsetting = new ODataMessageWriterSettings()
{
DisableMessageStreamDisposal = true,
ODataUri = new ODataUri()
{
ServiceRoot = new Uri("http://example.org/svc/"),
Path = path
}
};
IODataResponseMessage msg = new Message()
{
Stream = stream,
};
var omw = new ODataMessageWriter(msg, wsetting);
var writer = omw.CreateODataFeedWriter();
writer.WriteStart(Feed);
writer.WriteStart(Entry);
writer.WriteEnd();
writer.WriteEnd();
stream.Seek(0, SeekOrigin.Begin);
var payload = new StreamReader(stream).ReadToEnd();
// {"@odata.context":"http://example.org/svc/$metadata#Web/Items","value":[{"@odata.editLink":"http://example/Web/Users(3)","Id":2}]}
Console.WriteLine(payload);
//Read
ODataEntry entry = null;
stream.Seek(0, SeekOrigin.Begin);
var rsetting = new ODataMessageReaderSettings();
var omr = new ODataMessageReader(msg, rsetting, CraftModel.Model);
var reader = omr.CreateODataFeedReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
entry = (ODataEntry)reader.Item;
break;
}
}
//Id=2
foreach (var prop in entry.Properties)
{
Console.WriteLine("{0}={1}", prop.Name, prop.Value);
}
}
private void ReadFeedPayload(string payload, Action<ODataReader> action, bool isResponse = true, ODataVersion maxProtocolVersion = ODataVersion.V4)
{
if (isResponse)
{
IODataResponseMessage message = new InMemoryMessage() { Stream = new MemoryStream(Encoding.UTF8.GetBytes(payload)), StatusCode = 200 };
message.SetHeader("Content-Type", "application/atom+xml;type=feed");
ODataMessageReaderSettings settings = new ODataMessageReaderSettings()
{
MaxProtocolVersion = maxProtocolVersion,
EnableAtom = true
};
using (var msgReader = new ODataMessageReader(message, settings))
{
var reader = msgReader.CreateODataFeedReader();
while (reader.Read())
{
action(reader);
}
}
}
else
{
IODataRequestMessage message = new InMemoryMessage() { Stream = new MemoryStream(Encoding.UTF8.GetBytes(payload)), Method = "GET" };
message.SetHeader("Content-Type", "application/atom+xml;type=feed");
ODataMessageReaderSettings settings = new ODataMessageReaderSettings()
{
MaxProtocolVersion = maxProtocolVersion,
EnableAtom = true
};
using (var msgReader = new ODataMessageReader(message, settings))
{
var reader = msgReader.CreateODataFeedReader();
while (reader.Read())
{
action(reader);
}
}
}
}
public void ExecuteBaseballStatsRequest(IEdmModel model, string fileName)
{
//we are going to create a GET request to the OData Netflix Catalog
HTTPClientRequestMessage message = new HTTPClientRequestMessage("http://baseball-stats.info/OData/baseballstats.svc/");
message.SetHeader("Accept", "application/atom+xml");
message.SetHeader("DataServiceVersion", ODataUtils.ODataVersionToString(ODataVersion.V2));
message.SetHeader("MaxDataServiceVersion", ODataUtils.ODataVersionToString(ODataVersion.V2));
//create a simple text file to write the response to and create a text writer
string filePath = @".\out\" + fileName + ".txt";
using (StreamWriter outputWriter = new StreamWriter(filePath))
{
//use an indented text writer for readability
this.writer = new IndentedTextWriter(outputWriter, " ");
//issue the request and get the response as an ODataMessage. Create an ODataMessageReader over the response
//we will use the model when creating the reader as this will tell the library to validate when parsing
using (ODataMessageReader messageReader = new ODataMessageReader(message.GetResponse(),
new ODataMessageReaderSettings(), model))
{
//create a feed reader
ODataReader reader = messageReader.CreateODataFeedReader();
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.FeedStart:
{
//this is just the beginning of the feed, data will not be parsed yet
ODataFeed feed = (ODataFeed)reader.Item;
this.writer.WriteLine("ODataFeed:");
this.writer.Indent++;
}
break;
case ODataReaderState.FeedEnd:
{
//this is the end of feed state. The entire message has been read at this point
ODataFeed feed = (ODataFeed)reader.Item;
if (feed.Count != null)
{
//if there is an inlinecount value write the value out
this.writer.WriteLine("Count: " + feed.Count.ToString());
}
if (feed.NextPageLink != null)
{
//if there is a next link write that link as well
this.writer.WriteLine("NextPageLink: " + feed.NextPageLink.AbsoluteUri);
}
this.writer.Indent--;
}
break;
case ODataReaderState.EntryStart:
{
//this is just the start of the entry.
//Properties of the entity will not be parsed yet
ODataEntry entry = (ODataEntry)reader.Item;
this.writer.WriteLine("ODataEntry:");
this.writer.Indent++;
}
break;
case ODataReaderState.EntryEnd:
{
//at the point the whole entry has been read
//and the properties of the entity are available
ODataEntry entry = (ODataEntry)reader.Item;
this.writer.WriteLine("TypeName: " + (entry.TypeName ?? "<null>"));
this.writer.WriteLine("Id: " + (entry.Id ?? "<null>"));
if (entry.ReadLink != null)
{
this.writer.WriteLine("ReadLink: " + entry.ReadLink.AbsoluteUri);
}
if (entry.EditLink != null)
{
this.writer.WriteLine("EditLink: " + entry.EditLink.AbsoluteUri);
}
if (entry.MediaResource != null)
{
this.writer.Write("MediaResource: ");
this.WriteValue(entry.MediaResource);
}
this.WriteProperties(entry.Properties);
this.writer.Indent--;
}
break;
case ODataReaderState.NavigationLinkStart:
{
//navigation links have their own states.
//This could be an expanded link and include an entire expanded entry or feed.
ODataNavigationLink navigationLink = (ODataNavigationLink)reader.Item;
this.writer.WriteLine(navigationLink.Name + ": ODataNavigationLink: ");
this.writer.Indent++;
}
break;
case ODataReaderState.NavigationLinkEnd:
{
ODataNavigationLink navigationLink = (ODataNavigationLink)reader.Item;
this.writer.WriteLine("Url: " +
(navigationLink.Url == null ? "<null>" : navigationLink.Url.AbsoluteUri));
this.writer.Indent--;
}
break;
}
}
}
}
}
protected static ODataReader CreateODataReader(ODataMessageReader messageReader, ODataPayloadKind messageType, IEdmType expectedType, DataServiceProtocolVersion protocolVersion)
{
if (expectedType != null)
{
ClientEdmModel.GetModel(protocolVersion).GetClientTypeAnnotation(expectedType).EnsureEPMLoaded();
}
IEdmEntityType expectedEntityType = expectedType as IEdmEntityType;
if (messageType == ODataPayloadKind.Entry)
{
return messageReader.CreateODataEntryReader(expectedEntityType);
}
return messageReader.CreateODataFeedReader(expectedEntityType);
}
private void PrimitiveValueInSkipTokenInURL(string skipTokenQuery)
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings() { BaseUri = this.ServiceUri };
foreach (var mimeType in mimeTypes)
{
var requestMessage = new Microsoft.Test.OData.Tests.Client.Common.HttpWebRequestMessage(new Uri(this.ServiceUri.AbsoluteUri + skipTokenQuery, UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, RetrieveServiceEdmModel()))
{
var reader = messageReader.CreateODataFeedReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
string pattern = skipTokenQuery.Substring(0, skipTokenQuery.IndexOf("?")) + @"\(" + dataPattern + @"\)$";
Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
ODataEntry entry = reader.Item as ODataEntry;
Assert.IsTrue(rgx.Match(entry.Id.ToString()).Success, "Expected : Entry's Id doesn't contain trailing when Key is Int64/float/double/decimal");
if (mimeType.Equals(MimeTypes.ApplicationJson + MimeTypes.ODataParameterFullMetadata))
{
Assert.IsTrue(rgx.Match(entry.EditLink.ToString()).Success, "Expected : Entry's EditLink doesn't contain trailing when Key is Int64/float/double/decimal");
Assert.IsTrue(rgx.Match(entry.ReadLink.ToString()).Success, "Expected : Entry's ReadLink doesn't contain trailing when Key is Int64/float/double/decimal");
}
}
else if (reader.State == ODataReaderState.FeedEnd)
{
var pattern = skipTokenQuery.Substring(0, skipTokenQuery.IndexOf("?")) + @"\?\$skiptoken=" + dataPattern + "$";
Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
ODataFeed feed = reader.Item as ODataFeed;
Assert.IsTrue(rgx.Match(feed.NextPageLink.ToString()).Success, "Expected : Feed's NextLink doesn't contain trailing when Key is Int64/float/double/decimal");
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
}
}
}
private void CreateAndReadResponseMessageWithFeed(string startingString, string cycleString)
{
var model = this.GetModel();
if (model != null)
{
var responseMessage = new ODataUnlimitedResponseMessage(startingString, cycleString);
responseMessage.SetHeader("Content-Type", "application/json");
responseMessage.SetHeader("DataServiceVersion", "3.0");
var readLimitReached = false;
try
{
using (var messageReader = new ODataMessageReader(responseMessage, new ODataMessageReaderSettings(), model))
{
var feedReader = messageReader.CreateODataFeedReader();
while (feedReader.Read())
{
switch (feedReader.State)
{
case ODataReaderState.FeedStart:
Console.WriteLine("FeedStart: " + (ODataFeed)feedReader.Item);
break;
case ODataReaderState.FeedEnd:
Console.WriteLine("FeedEnd: " + (ODataFeed)feedReader.Item);
break;
case ODataReaderState.EntryStart:
Console.WriteLine("EntryStart: " + (ODataEntry)feedReader.Item);
break;
case ODataReaderState.EntryEnd:
Console.WriteLine("EntryEnd: " + (ODataEntry)feedReader.Item);
break;
default:
Console.WriteLine("ODataItem: " + feedReader.Item);
break;
}
}
}
}
catch (ODataException ex)
{
if (ex.Message.StartsWith("The maximum number of bytes allowed to be read from the stream has been exceeded."))
{
readLimitReached = true;
}
else
{
throw;
}
}
if (!readLimitReached)
{
throw new InvalidOperationException("Expecting exception, but it was not thrown.");
}
}
}
/// <summary>
/// Creates an OData reader to read OData feed download response.
/// </summary>
/// <param name="reader">The message reader containing current OData feed download response.</param>
/// <returns>an OData reader to read OData feed download response</returns>
private ODataReader CreateReader(ODataMessageReader reader)
{
ODataReader resultReader = null;
resultReader = reader.CreateODataFeedReader();
return resultReader;
}
public void QueryWithFormat()
{
Dictionary<string, string> testCases = new Dictionary<string, string>()
{
{"People?$format=application/json", "application/json"},
// ODL Bug: https://github.com/OData/odata.net/issues/313
////{"People?$format=application/json;odata.metadata=full", "application/json; odata.metadata=full"},
{"People?$format=json", "application/json"},
};
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings() { BaseUri = ServiceBaseUri };
foreach (var testCase in testCases)
{
DataServiceClientRequestMessageArgs args = new DataServiceClientRequestMessageArgs(
"GET",
new Uri(ServiceBaseUri.AbsoluteUri + testCase.Key, UriKind.Absolute),
false, false, new Dictionary<string, string>() { });
var requestMessage = new HttpWebRequestMessage(args);
using (var responseMessage = requestMessage.GetResponse() as HttpWebResponseMessage)
{
Assert.Equal(200, responseMessage.StatusCode);
string contentType = responseMessage.Headers.FirstOrDefault(x => x.Key.Equals("Content-Type")).Value;
Assert.True(contentType.StartsWith(testCase.Value));
using (var messageReader = new ODataMessageReader(
responseMessage,
readerSettings,
this.TestClientContext.Format.LoadServiceModel()))
{
var reader = messageReader.CreateODataFeedReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
ODataEntry entry = reader.Item as ODataEntry;
Assert.NotNull(entry.Properties.Single(p => p.Name == "PersonId").Value);
}
else if (reader.State == ODataReaderState.FeedEnd)
{
Assert.NotNull(reader.Item as ODataFeed);
}
}
Assert.Equal(ODataReaderState.Completed, reader.State);
}
}
}
}
void CheckResponse(ODataMessageReader mreader)
{
using (mreader)
{
var reader = mreader.CreateODataFeedReader();
while (reader.Read())
{
Assert.IsNotNull(reader.State);
switch (reader.State)
{
case ODataReaderState.FeedStart:
{
ODataFeed feed = (ODataFeed)reader.Item;
}
break;
case ODataReaderState.FeedEnd:
{
ODataFeed feed = (ODataFeed)reader.Item;
if (feed.Count != null)
{
//this.writer.WriteLine("Count: " + feed.Count.ToString());
}
if (feed.NextPageLink != null)
{
//this.writer.WriteLine("NextPageLink: " + feed.NextPageLink.AbsoluteUri);
}
}
break;
case ODataReaderState.EntryStart:
{
ODataEntry entry = (ODataEntry)reader.Item;
}
break;
case ODataReaderState.EntryEnd:
{
ODataEntry entry = (ODataEntry)reader.Item;
// this.writer.WriteLine("TypeName: " + (entry.TypeName ?? "<null>"));
// this.writer.WriteLine("Id: " + (entry.Id ?? "<null>"));
if (entry.ReadLink != null)
{
// this.writer.WriteLine("ReadLink: " + entry.ReadLink.AbsoluteUri);
}
if (entry.EditLink != null)
{
//this.writer.WriteLine("EditLink: " + entry.EditLink.AbsoluteUri);
}
if (entry.MediaResource != null)
{
// this.writer.Write("MediaResource: ");
// this.WriteValue(entry.MediaResource);
}
// this.WriteProperties(entry.Properties);
foreach (ODataProperty property in entry.Properties)
{
// this.writer.Write(property.Name + ": ");
// this.WriteValue(property.Value);
}
foreach (var assoc in entry.AssociationLinks)
{
//do something
}
// this.writer.Indent--;
}
break;
case ODataReaderState.NavigationLinkStart:
{
ODataNavigationLink navigationLink = (ODataNavigationLink)reader.Item;
// this.writer.WriteLine(navigationLink.Name + ": ODataNavigationLink: ");
// this.writer.Indent++;
}
break;
case ODataReaderState.NavigationLinkEnd:
{
ODataNavigationLink navigationLink = (ODataNavigationLink)reader.Item;
// this.writer.WriteLine("Url: " + (navigationLink.Url == null ? "<null>" : navigationLink.Url.AbsoluteUri));
// this.writer.Indent--;
}
break;
}
}
}
}
public void ShouldBeAbleToReadCustomInstanceAnnotationFromFeedAndEntry(string payload, string contentType)
{
var stream = new MemoryStream(Encoding.UTF8.GetBytes(payload));
var readerSettings = new ODataMessageReaderSettings { DisableMessageStreamDisposal = false, EnableAtom = true };
IODataResponseMessage messageToRead = new InMemoryMessage { StatusCode = 200, Stream = stream };
messageToRead.SetHeader("Content-Type", contentType);
// Enable reading custom instance annotations.
messageToRead.PreferenceAppliedHeader().AnnotationFilter = "Custom.*";
Stack<ODataItem> odataItems = new Stack<ODataItem>(4);
using (var messageReader = new ODataMessageReader(messageToRead, readerSettings, Model))
{
var odataReader = messageReader.CreateODataFeedReader(EntitySet, EntityType);
ICollection<ODataInstanceAnnotation> instanceAnnotations = null;
while (odataReader.Read())
{
switch (odataReader.State)
{
case ODataReaderState.FeedStart:
odataItems.Push(odataReader.Item);
instanceAnnotations = odataItems.Peek().As<ODataFeed>().InstanceAnnotations;
// TODO: We only support instance annotation at the top level feed at the moment. Will remove the if statement when support on inline feed is added.
if (odataItems.Count == 1)
{
// Note that in streaming mode, the collection should be populated with instance annotations read so far before the beginning of the first entry.
// We are currently in non-streaming mode. The reader will buffer the payload and read ahead till the
// end of the feed to read all instance annotations.
instanceAnnotations.Should().HaveCount(1);
TestUtils.AssertODataValueAreEqual(new ODataPrimitiveValue(odataItems.Count), instanceAnnotations.Single(ia => ia.Name == "Custom.FeedStartAnnotation").Value);
}
else
{
instanceAnnotations.Should().BeEmpty();
}
break;
case ODataReaderState.FeedEnd:
instanceAnnotations = odataItems.Peek().As<ODataFeed>().InstanceAnnotations;
// TODO: We only support instance annotation at the top level feed at the moment. Will remove the if statement when support on inline feed is added.
if (odataItems.Count == 1)
{
instanceAnnotations.Should().HaveCount(2);
TestUtils.AssertODataValueAreEqual(new ODataPrimitiveValue(1), instanceAnnotations.Single(ia => ia.Name == "Custom.FeedStartAnnotation").Value);
TestUtils.AssertODataValueAreEqual(new ODataPrimitiveValue(1), instanceAnnotations.Single(ia => ia.Name == "Custom.FeedEndAnnotation").Value);
}
else
{
instanceAnnotations.Should().BeEmpty();
}
odataItems.Pop();
break;
case ODataReaderState.NavigationLinkStart:
ODataNavigationLink navigationLink = (ODataNavigationLink)odataReader.Item;
if (navigationLink.Name == "ResourceSetNavigationProperty")
{
// The collection should be populated with instance annotations read so far before the "ResourceSetNavigationProperty".
instanceAnnotations = odataItems.Peek().As<ODataEntry>().InstanceAnnotations;
instanceAnnotations.Should().HaveCount(2);
TestUtils.AssertODataValueAreEqual(new ODataPrimitiveValue(odataItems.Count), instanceAnnotations.Single(ia => ia.Name == "Custom.EntryStartAnnotation").Value);
TestUtils.AssertODataValueAreEqual(new ODataPrimitiveValue(odataItems.Count), instanceAnnotations.Single(ia => ia.Name == "Custom.EntryMiddleAnnotation").Value);
}
break;
case ODataReaderState.NavigationLinkEnd:
break;
case ODataReaderState.EntryStart:
odataItems.Push(odataReader.Item);
// The collection should be populated with instance annotations read so far before the first navigation/association link or before the end of the entry.
instanceAnnotations = odataItems.Peek().As<ODataEntry>().InstanceAnnotations;
instanceAnnotations.Should().HaveCount(1);
TestUtils.AssertODataValueAreEqual(new ODataPrimitiveValue(odataItems.Count), instanceAnnotations.Single(ia => ia.Name == "Custom.EntryStartAnnotation").Value);
break;
case ODataReaderState.EntryEnd:
instanceAnnotations = odataItems.Peek().As<ODataEntry>().InstanceAnnotations;
instanceAnnotations.Should().HaveCount(3);
TestUtils.AssertODataValueAreEqual(new ODataPrimitiveValue(odataItems.Count), instanceAnnotations.Single(ia => ia.Name == "Custom.EntryStartAnnotation").Value);
TestUtils.AssertODataValueAreEqual(new ODataPrimitiveValue(odataItems.Count), instanceAnnotations.Single(ia => ia.Name == "Custom.EntryMiddleAnnotation").Value);
TestUtils.AssertODataValueAreEqual(new ODataPrimitiveValue(odataItems.Count), instanceAnnotations.Single(ia => ia.Name == "Custom.EntryEndAnnotation").Value);
odataItems.Pop();
break;
}
}
instanceAnnotations.Should().HaveCount(2);
TestUtils.AssertODataValueAreEqual(new ODataPrimitiveValue(1), instanceAnnotations.Single(ia => ia.Name == "Custom.FeedStartAnnotation").Value);
TestUtils.AssertODataValueAreEqual(new ODataPrimitiveValue(1), instanceAnnotations.Single(ia => ia.Name == "Custom.FeedEndAnnotation").Value);
}
}
private static ODataResult GetODataResult(ODataMessageReader messageReader)
{
List<ODataPayloadKindDetectionResult> payloadKinds = messageReader.DetectPayloadKind().ToList();
if (payloadKinds.Count > 0)
{
switch (payloadKinds[0].PayloadKind)
{
case ODataPayloadKind.Feed:
return new FeedODataResult(messageReader.CreateODataFeedReader());
case ODataPayloadKind.Entry:
return new FeedODataResult(messageReader.CreateODataEntryReader());
}
throw new InvalidOperationException("unsupported payload kind " + payloadKinds[0].PayloadKind);
}
throw new InvalidOperationException("unknown payload kind");
}
public void CustomInstanceAnnotationFromFeedAndEntryInJsonLightShouldBeSkippedByTheReaderByDefault()
{
var stream = new MemoryStream(Encoding.UTF8.GetBytes(JsonLightFeedAndEntryPayloadWithCustomInstanceAnnotations));
var readerSettings = new ODataMessageReaderSettings { DisableMessageStreamDisposal = false };
IODataResponseMessage messageToRead = new InMemoryMessage { StatusCode = 200, Stream = stream };
messageToRead.SetHeader("Content-Type", "application/json;odata.streaming=true");
using (var messageReader = new ODataMessageReader(messageToRead, readerSettings, Model))
{
var odataReader = messageReader.CreateODataFeedReader(EntitySet, EntityType);
while (odataReader.Read())
{
switch (odataReader.State)
{
case ODataReaderState.FeedStart:
case ODataReaderState.FeedEnd:
odataReader.Item.As<ODataFeed>().InstanceAnnotations.Should().BeEmpty();
break;
case ODataReaderState.NavigationLinkStart:
case ODataReaderState.NavigationLinkEnd:
break;
case ODataReaderState.EntryStart:
case ODataReaderState.EntryEnd:
odataReader.Item.As<ODataEntry>().InstanceAnnotations.Should().BeEmpty();
break;
}
}
}
}
private void ReadFeedPayload(string payload, Action<ODataReader> action)
{
var message = new InMemoryMessage() { Stream = new MemoryStream(Encoding.UTF8.GetBytes(payload)) };
message.SetHeader("Content-Type", "application/atom+xml;type=feed");
message.PreferenceAppliedHeader().AnnotationFilter = "*";
using (var msgReader = new ODataMessageReader((IODataResponseMessage)message, atomReaderSettings))
{
var reader = msgReader.CreateODataFeedReader();
while (reader.Read())
{
action(reader);
}
}
}
public void TestCreateODataFeedReader_InJsonLight_WithEntityTypeButWithoutSet_Throws()
{
// Arrange
IODataRequestMessage request = CreateJsonLightRequest();
ODataMessageReaderSettings settings = CreateSettings();
IEdmModel model = CreateModel();
IEdmEntityType entityType = model.EntityContainer.EntitySets().First().EntityType();
using (ODataMessageReader reader = new ODataMessageReader(request, settings, model))
{
// Act & Assert
Assert.Throws<ODataException>(() => reader.CreateODataFeedReader(entityType));
}
}
public void TestCreateODataFeedReader_InJsonLight_WithEntitySetButWithoutType_DoesNotThrow()
{
// Arrange
IODataRequestMessage request = CreateJsonLightRequest();
ODataMessageReaderSettings settings = CreateSettings();
IEdmModel model = CreateModel();
IEdmEntitySet entitySet = model.EntityContainer.EntitySets().First();
using (ODataMessageReader reader = new ODataMessageReader(request, settings, model))
{
// Act & Assert
Assert.DoesNotThrow(() => reader.CreateODataFeedReader(entitySet, null));
}
}
internal static object ConvertFeed(ODataMessageReader oDataMessageReader, IEdmTypeReference edmTypeReference, ODataDeserializerContext readContext)
{
IEdmCollectionTypeReference collectionType = edmTypeReference.AsCollection();
EdmEntitySet tempEntitySet = new EdmEntitySet(readContext.Model.EntityContainer, "temp",
collectionType.ElementType().AsEntity().EntityDefinition());
ODataReader odataReader = oDataMessageReader.CreateODataFeedReader(tempEntitySet,
collectionType.ElementType().AsEntity().EntityDefinition());
ODataFeedWithEntries feed =
ODataEntityDeserializer.ReadEntryOrFeed(odataReader) as ODataFeedWithEntries;
ODataFeedDeserializer feedDeserializer =
(ODataFeedDeserializer)DeserializerProvider.GetEdmTypeDeserializer(collectionType);
object result = feedDeserializer.ReadInline(feed, collectionType, readContext);
IEnumerable enumerable = result as IEnumerable;
if (enumerable != null)
{
IEnumerable newEnumerable = CovertFeedIds(enumerable, feed, collectionType, readContext);
if (readContext.IsUntyped)
{
EdmEntityObjectCollection entityCollection =
new EdmEntityObjectCollection(collectionType);
foreach (EdmEntityObject entity in newEnumerable)
{
entityCollection.Add(entity);
}
return entityCollection;
}
else
{
IEdmTypeReference elementTypeReference = collectionType.ElementType();
Type elementClrType = EdmLibHelpers.GetClrType(elementTypeReference,
readContext.Model);
IEnumerable castedResult =
CastMethodInfo.MakeGenericMethod(elementClrType)
.Invoke(null, new object[] { newEnumerable }) as IEnumerable;
return castedResult;
}
}
return null;
}
public void ReadingInMinialMetadataModeUseDefaultCtorWithContainedEntitySetOfAnotherTypeShouldBeAbleToGenerateId()
{
const string payload =
"{" +
"\"@odata.context\":\"http://example.com/$metadata#EntitySet(1)/AnotherContainedNavProp\"," +
"\"value\":[" +
"{" +
"\"ID\" : 123," +
"\"Name\" : \"Bob\"" +
"}" +
"] }";
InMemoryMessage message = new InMemoryMessage();
message.SetHeader("Content-Type", "application/json;odata.metadata=minimal");
message.Stream = new MemoryStream(Encoding.UTF8.GetBytes(payload));
ODataEntry topLevelEntry = null;
List<ODataEntry> entryList = new List<ODataEntry>();
using (var messageReader = new ODataMessageReader((IODataResponseMessage)message, null, Model))
{
var reader = messageReader.CreateODataFeedReader();
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.EntryEnd:
topLevelEntry = (ODataEntry)reader.Item;
entryList.Add(topLevelEntry);
break;
}
}
}
Uri containedId = new Uri("http://example.com/EntitySet(1)/AnotherContainedNavProp(123)");
ODataEntry containedEntry = entryList[0];
containedEntry.Id.Should().Be(containedId);
}
