private string WriteAndVerifyCarEntry(ODataMessageWriterSettings settings, string mimeType, bool hasModel)
{
// create a car entry
var carEntry = WritePayloadHelper.CreateCarEntryNoMetadata(hasModel);
carEntry.MediaResource = new ODataStreamReferenceValue();
Dictionary <string, object> expectedCarObject = WritePayloadHelper.ComputeExpectedFullMetadataEntryObject(WritePayloadHelper.CarType, "Car(11)", carEntry, hasModel);
WritePayloadHelper.ComputeDefaultExpectedFullMetadataEntryMedia(WritePayloadHelper.CarType, "Car(11)", carEntry, expectedCarObject, true /*hasStream*/, hasModel);
// write the response message and read using ODL reader
var responseMessage = new StreamResponseMessage(new MemoryStream());
responseMessage.SetHeader("Content-Type", mimeType);
responseMessage.PreferenceAppliedHeader().AnnotationFilter = "foo.*";
string result = string.Empty;
using (var messageWriter = this.CreateODataMessageWriter(responseMessage, settings, hasModel))
{
var odataWriter = this.CreateODataEntryWriter(messageWriter, WritePayloadHelper.CarSet, WritePayloadHelper.CarType, hasModel);
odataWriter.WriteStart(carEntry);
odataWriter.WriteEnd();
result = this.ReadFeedEntryMessage(false, responseMessage, mimeType, WritePayloadHelper.CarSet, WritePayloadHelper.CarType);
}
// For Json light, verify the resulting metadata is as expected
if (mimeType != MimeTypes.ApplicationAtomXml)
{
JavaScriptSerializer jScriptSerializer = new JavaScriptSerializer();
Dictionary <string, object> resultObject = jScriptSerializer.DeserializeObject(result) as Dictionary <string, object>;
VerifyODataContextAnnotation(this.ServiceUri + "$metadata#Car/$entity", resultObject, mimeType);
VerifyEntry(expectedCarObject, carEntry, new ODataNavigationLink[] { }, new ODataProperty[] { }, resultObject, mimeType, settings.AutoComputePayloadMetadataInJson);
}
return(result);
}
private string WriteAndVerifyOrderFeed(ODataMessageWriterSettings settings, string mimeType, bool hasModel)
{
// create a feed with two entries
var orderFeed = new ODataFeed()
{
NextPageLink = new Uri(this.ServiceUri + "Order?$skiptoken=-9"),
Count = 9999
};
if (mimeType == MimeTypes.ApplicationAtomXml)
{
orderFeed.Id = new Uri(this.ServiceUri + "Order");
}
if (!hasModel)
{
orderFeed.SetSerializationInfo(new ODataFeedAndEntrySerializationInfo()
{
NavigationSourceName = "Order", NavigationSourceEntityTypeName = NameSpace + "Order"
});
}
var orderEntry1 = WritePayloadHelper.CreateOrderEntry1NoMetadata(hasModel);
Dictionary <string, object> expectedOrderObject1 = WritePayloadHelper.ComputeExpectedFullMetadataEntryObject(WritePayloadHelper.OrderType, "Order(-10)", orderEntry1, hasModel);
var orderEntry2 = WritePayloadHelper.CreateOrderEntry2NoMetadata(hasModel);
Dictionary <string, object> expectedOrderObject2 = WritePayloadHelper.ComputeExpectedFullMetadataEntryObject(WritePayloadHelper.OrderType, "Order(-9)", orderEntry2, hasModel);
var orderEntry2Navigation = WritePayloadHelper.AddOrderEntryCustomNavigation(orderEntry2, expectedOrderObject2, hasModel);
// write the response message and read using ODL reader
var responseMessage = new StreamResponseMessage(new MemoryStream());
responseMessage.SetHeader("Content-Type", mimeType);
string result = string.Empty;
using (var messageWriter = this.CreateODataMessageWriter(responseMessage, settings, hasModel))
{
var odataWriter = this.CreateODataFeedWriter(messageWriter, WritePayloadHelper.OrderSet, WritePayloadHelper.OrderType, hasModel);
odataWriter.WriteStart(orderFeed);
odataWriter.WriteStart(orderEntry1);
odataWriter.WriteEnd();
odataWriter.WriteStart(orderEntry2);
odataWriter.WriteStart(orderEntry2Navigation);
odataWriter.WriteEnd();
odataWriter.WriteEnd();
// Finish writing the feed.
odataWriter.WriteEnd();
result = this.ReadFeedEntryMessage(true, responseMessage, mimeType, WritePayloadHelper.OrderSet, WritePayloadHelper.OrderType);
}
if (mimeType != MimeTypes.ApplicationAtomXml)
{
JavaScriptSerializer jScriptSerializer = new JavaScriptSerializer();
Dictionary <string, object> resultObject = jScriptSerializer.DeserializeObject(result) as Dictionary <string, object>;
Assert.AreEqual(this.ServiceUri + "Order?$skiptoken=-9", resultObject.Single(e => e.Key == (JsonLightConstants.ODataNextLinkAnnotationName)).Value, "Feed next link");
Assert.AreEqual(9999, resultObject.Single(e => e.Key == (JsonLightConstants.ODataCountAnnotationName)).Value, "Feed count");
resultObject.Remove(JsonLightConstants.ODataNextLinkAnnotationName);
resultObject.Remove(JsonLightConstants.ODataCountAnnotationName);
VerifyODataContextAnnotation(this.ServiceUri + "$metadata#Order", resultObject, mimeType);
VerifyEntry(expectedOrderObject1, orderEntry1, new ODataNavigationLink[] { }, new ODataProperty[] { }, (resultObject.Last().Value as object[]).First() as Dictionary <string, object>, mimeType, settings.AutoComputePayloadMetadataInJson);
VerifyEntry(expectedOrderObject2, orderEntry2, new ODataNavigationLink[] { orderEntry2Navigation }, new ODataProperty[] { }, (resultObject.Last().Value as object[]).Last() as Dictionary <string, object>, mimeType, settings.AutoComputePayloadMetadataInJson);
}
return(result);
}
private string WriteAndVerifyEmployeeFeed(ODataMessageWriterSettings settings, string mimeType, bool hasModel)
{
// create a feed with two entries
var employeeFeed = new ODataFeed();
if (mimeType == MimeTypes.ApplicationAtomXml)
{
employeeFeed.Id = new Uri(this.ServiceUri + "Person/" + NameSpace + "Employee");
}
if (!hasModel)
{
employeeFeed.SetSerializationInfo(new ODataFeedAndEntrySerializationInfo()
{
NavigationSourceName = "Person", NavigationSourceEntityTypeName = NameSpace + "Person", ExpectedTypeName = NameSpace + "Employee"
});
}
ODataEntry employeeEntry = WritePayloadHelper.CreateEmployeeEntryNoMetadata(false);
ODataEntry specialEmployeeEntry = WritePayloadHelper.CreateSpecialEmployeeEntryNoMetadata(false);
// expected result with AutoGeneratedUrlsShouldPutKeyValueInDedicatedSegment
Dictionary <string, object> expectedEmployeeObject = WritePayloadHelper.ComputeExpectedFullMetadataEntryObject(WritePayloadHelper.EmployeeType, "Person/-3", employeeEntry, hasModel, true);
Dictionary <string, object> expectedSpecialEmployeeObject = WritePayloadHelper.ComputeExpectedFullMetadataEntryObject(WritePayloadHelper.SpecialEmployeeType, "Person/-10", specialEmployeeEntry, hasModel, true);
// write the response message and read using ODL reader
var responseMessage = new StreamResponseMessage(new MemoryStream());
responseMessage.SetHeader("Content-Type", mimeType);
string result = string.Empty;
using (var messageWriter = this.CreateODataMessageWriter(responseMessage, settings, hasModel))
{
var odataWriter = this.CreateODataFeedWriter(messageWriter, WritePayloadHelper.PersonSet, WritePayloadHelper.EmployeeType, hasModel);
odataWriter.WriteStart(employeeFeed);
odataWriter.WriteStart(employeeEntry);
odataWriter.WriteEnd();
// toggle AutoComputePayloadMetadataInJson, this should not affect the writing result
settings.AutoComputePayloadMetadataInJson = !settings.AutoComputePayloadMetadataInJson;
odataWriter.WriteStart(specialEmployeeEntry);
odataWriter.WriteEnd();
odataWriter.WriteEnd();
result = this.ReadFeedEntryMessage(true, responseMessage, mimeType, WritePayloadHelper.PersonSet, WritePayloadHelper.PersonType);
}
// For Json light, verify the resulting metadata is as expected
if (mimeType != MimeTypes.ApplicationAtomXml)
{
JavaScriptSerializer jScriptSerializer = new JavaScriptSerializer();
Dictionary <string, object> resultObject = jScriptSerializer.DeserializeObject(result) as Dictionary <string, object>;
VerifyODataContextAnnotation(this.ServiceUri + "$metadata#Person/" + NameSpace + "Employee", resultObject, mimeType);
settings.AutoComputePayloadMetadataInJson = !settings.AutoComputePayloadMetadataInJson;
VerifyEntry(expectedEmployeeObject, employeeEntry, new ODataNavigationLink[] { }, new ODataProperty[] { }, (resultObject.Last().Value as object[]).First() as Dictionary <string, object>, mimeType, settings.AutoComputePayloadMetadataInJson);
VerifyEntry(expectedSpecialEmployeeObject, specialEmployeeEntry, new ODataNavigationLink[] { }, new ODataProperty[] { }, (resultObject.Last().Value as object[]).Last() as Dictionary <string, object>, mimeType, settings.AutoComputePayloadMetadataInJson);
}
return(result);
}
private string WriteAndVerifyRequestMessage(ODataMessageWriterSettings settings, string mimeType, bool hasModel)
{
// create an order entry to POST
var order = new ODataEntry()
{
TypeName = NameSpace + "Order"
};
var orderP1 = new ODataProperty {
Name = "OrderId", Value = -10
};
var orderp2 = new ODataProperty {
Name = "CustomerId", Value = 8212
};
var orderp3 = new ODataProperty {
Name = "Concurrency", Value = null
};
order.Properties = new[] { orderP1, orderp2, orderp3 };
if (!hasModel)
{
order.SetSerializationInfo(new ODataFeedAndEntrySerializationInfo()
{
NavigationSourceName = "Order", NavigationSourceEntityTypeName = NameSpace + "Order"
});
orderP1.SetSerializationInfo(new ODataPropertySerializationInfo()
{
PropertyKind = ODataPropertyKind.Key
});
}
Dictionary <string, object> expectedOrderObject = WritePayloadHelper.ComputeExpectedFullMetadataEntryObject(WritePayloadHelper.OrderType, "Order(-10)", order, hasModel);
// write the request message and read using ODL reader
var requestMessage = new StreamRequestMessage(new MemoryStream(), new Uri(this.ServiceUri + "Order"), "POST");
requestMessage.SetHeader("Content-Type", mimeType);
string result = string.Empty;
using (var messageWriter = this.CreateODataMessageWriter(requestMessage, settings, hasModel))
{
var odataWriter = this.CreateODataEntryWriter(messageWriter, WritePayloadHelper.OrderSet, WritePayloadHelper.OrderType, hasModel);
odataWriter.WriteStart(order);
odataWriter.WriteEnd();
Stream stream = requestMessage.GetStream();
result = WritePayloadHelper.ReadStreamContent(stream);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
stream.Seek(0, SeekOrigin.Begin);
var readerSetting = new ODataMessageReaderSettings()
{
BaseUri = this.ServiceUri
};
ODataMessageReader messageReader = new ODataMessageReader(requestMessage, readerSetting, WritePayloadHelper.Model);
ODataReader reader = messageReader.CreateODataEntryReader(WritePayloadHelper.OrderSet, WritePayloadHelper.OrderType);
bool verifyEntryCalled = false;
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
ODataEntry entry = reader.Item as ODataEntry;
Assert.AreEqual(3, entry.Properties.Count(), "entry.Properties.Count");
verifyEntryCalled = true;
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
Assert.IsTrue(verifyEntryCalled, "verifyEntryCalled");
}
}
// For Json light, verify the resulting metadata is as expected
if (mimeType != MimeTypes.ApplicationAtomXml)
{
JavaScriptSerializer jScriptSerializer = new JavaScriptSerializer();
Dictionary <string, object> resultObject = jScriptSerializer.DeserializeObject(result) as Dictionary <string, object>;
// AutoComputePayloadMetadataInJson has no effect on request message metadata
Assert.AreEqual(this.ServiceUri + "$metadata#Order/$entity", resultObject.Single(e => e.Key == JsonLightConstants.ODataContextAnnotationName).Value);
resultObject.Remove(JsonLightConstants.ODataContextAnnotationName);
foreach (var pair in resultObject)
{
Assert.IsFalse(pair.Key.Contains("odata.") || pair.Key.StartsWith("#"));
}
}
return(result);
}
private string WriteAndVerifyPersonFeed(ODataMessageWriterSettings settings, string mimeType, bool hasModel)
{
// create a Person feed containing a person, an employee, a special employee
var personFeed = new ODataFeed();
if (mimeType == MimeTypes.ApplicationAtomXml)
{
personFeed.Id = new Uri(this.ServiceUri + "Person");
}
if (!hasModel)
{
personFeed.SetSerializationInfo(new ODataFeedAndEntrySerializationInfo()
{
NavigationSourceName = "Person", NavigationSourceEntityTypeName = NameSpace + "Person"
});
}
ODataEntry personEntry = WritePayloadHelper.CreatePersonEntryNoMetadata(hasModel);
Dictionary <string, object> expectedPersonObject = WritePayloadHelper.ComputeExpectedFullMetadataEntryObject(WritePayloadHelper.PersonType, "Person(-5)", personEntry, hasModel);
ODataEntry employeeEntry = WritePayloadHelper.CreateEmployeeEntryNoMetadata(hasModel);
Dictionary <string, object> expectedEmployeeObject = WritePayloadHelper.ComputeExpectedFullMetadataEntryObject(WritePayloadHelper.EmployeeType, "Person(-3)", employeeEntry, hasModel, true);
ODataEntry specialEmployeeEntry = WritePayloadHelper.CreateSpecialEmployeeEntryNoMetadata(hasModel);
Dictionary <string, object> expectedSpecialEmployeeObject = WritePayloadHelper.ComputeExpectedFullMetadataEntryObject(WritePayloadHelper.SpecialEmployeeType, "Person(-10)", specialEmployeeEntry, hasModel, true);
// write the response message and read using ODL reader
var responseMessage = new StreamResponseMessage(new MemoryStream());
responseMessage.SetHeader("Content-Type", mimeType);
string result = string.Empty;
using (var messageWriter = this.CreateODataMessageWriter(responseMessage, settings, hasModel))
{
var odataWriter = this.CreateODataFeedWriter(messageWriter, WritePayloadHelper.PersonSet, WritePayloadHelper.PersonType, hasModel);
odataWriter.WriteStart(personFeed);
odataWriter.WriteStart(personEntry);
odataWriter.WriteEnd();
odataWriter.WriteStart(employeeEntry);
odataWriter.WriteEnd();
odataWriter.WriteStart(specialEmployeeEntry);
odataWriter.WriteEnd();
// Finish writing the feed.
odataWriter.WriteEnd();
result = this.ReadFeedEntryMessage(true, responseMessage, mimeType, WritePayloadHelper.PersonSet, WritePayloadHelper.PersonType);
}
// For Json light, verify the resulting metadata is as expected
if (mimeType != MimeTypes.ApplicationAtomXml)
{
JavaScriptSerializer jScriptSerializer = new JavaScriptSerializer();
Dictionary <string, object> resultObject = jScriptSerializer.DeserializeObject(result) as Dictionary <string, object>;
VerifyODataContextAnnotation(this.ServiceUri + "$metadata#Person", resultObject, mimeType);
VerifyEntry(expectedPersonObject, personEntry, new ODataNavigationLink[] { }, new ODataProperty[] { }, (resultObject.Last().Value as object[]).ElementAt(0) as Dictionary <string, object>, mimeType, settings.AutoComputePayloadMetadataInJson);
VerifyEntry(expectedEmployeeObject, employeeEntry, new ODataNavigationLink[] { }, new ODataProperty[] { }, (resultObject.Last().Value as object[]).ElementAt(1) as Dictionary <string, object>, mimeType, settings.AutoComputePayloadMetadataInJson);
VerifyEntry(expectedSpecialEmployeeObject, specialEmployeeEntry, new ODataNavigationLink[] { }, new ODataProperty[] { }, (resultObject.Last().Value as object[]).ElementAt(2) as Dictionary <string, object>, mimeType, settings.AutoComputePayloadMetadataInJson);
}
return(result);
}
private string WriteAndVerifyExpandedCustomerEntry(ODataMessageWriterSettings settings, string mimeType, string expectedProjectionClause, bool hasModel)
{
ODataEntry customerEntry = WritePayloadHelper.CreateCustomerEntryNoMetadata(hasModel);
Dictionary <string, object> expectedCustomerObject = WritePayloadHelper.ComputeExpectedFullMetadataEntryObject(WritePayloadHelper.CustomerType, "Customer(-9)", customerEntry, hasModel);
var thumbnailProperty = WritePayloadHelper.AddCustomerMediaProperty(customerEntry, expectedCustomerObject);
// order navigation
var orderNavigation = WritePayloadHelper.CreateCustomerOrderNavigation(expectedCustomerObject);
// expanded logins navigation containing a Login instance
var expandedLoginsNavigation = WritePayloadHelper.CreateExpandedCustomerLoginsNavigation(expectedCustomerObject);
var loginFeed = new ODataFeed();
if (mimeType == MimeTypes.ApplicationAtomXml)
{
loginFeed.Id = new Uri(this.ServiceUri + "Customer(-9)/Logins");
}
if (!hasModel)
{
loginFeed.SetSerializationInfo(new ODataFeedAndEntrySerializationInfo()
{
NavigationSourceName = "Login", NavigationSourceEntityTypeName = NameSpace + "Login"
});
}
var loginEntry = WritePayloadHelper.CreateLoginEntryNoMetadata(hasModel);
Dictionary <string, object> expectedLoginObject = WritePayloadHelper.ComputeExpectedFullMetadataEntryObject(WritePayloadHelper.LoginType, "Login('2')", loginEntry, hasModel);
this.RemoveNonSelectedMetadataFromExpected(expectedCustomerObject, expectedLoginObject, hasModel);
// write the response message and read using ODL reader
var responseMessage = new StreamResponseMessage(new MemoryStream());
responseMessage.SetHeader("Content-Type", mimeType);
string result = string.Empty;
using (var messageWriter = this.CreateODataMessageWriter(responseMessage, settings, hasModel))
{
var odataWriter = this.CreateODataEntryWriter(messageWriter, WritePayloadHelper.CustomerSet, WritePayloadHelper.CustomerType, hasModel);
odataWriter.WriteStart(customerEntry);
odataWriter.WriteStart(orderNavigation);
odataWriter.WriteEnd();
// write expanded navigation
odataWriter.WriteStart(expandedLoginsNavigation);
odataWriter.WriteStart(loginFeed);
odataWriter.WriteStart(loginEntry);
odataWriter.WriteEnd();
odataWriter.WriteEnd();
// Finish writing expandedNavigation.
odataWriter.WriteEnd();
// Finish writing customerEntry.
odataWriter.WriteEnd();
result = this.ReadFeedEntryMessage(false, responseMessage, mimeType, WritePayloadHelper.CustomerSet, WritePayloadHelper.CustomerType);
}
// For Json light, verify the resulting metadata is as expected
if (mimeType != MimeTypes.ApplicationAtomXml)
{
JavaScriptSerializer jScriptSerializer = new JavaScriptSerializer();
Dictionary <string, object> resultObject = jScriptSerializer.DeserializeObject(result) as Dictionary <string, object>;
VerifyODataContextAnnotation(this.ServiceUri + "$metadata#Customer(" + expectedProjectionClause + ")/$entity", resultObject, mimeType);
VerifyEntry(expectedCustomerObject, customerEntry, new ODataNavigationLink[] { orderNavigation, expandedLoginsNavigation }, new ODataProperty[] { thumbnailProperty }, resultObject, mimeType, settings.AutoComputePayloadMetadataInJson);
VerifyEntry(expectedLoginObject, loginEntry, new ODataNavigationLink[] { }, new ODataProperty[] { }, (resultObject["Logins"] as object[]).Single() as Dictionary <string, object>, mimeType, settings.AutoComputePayloadMetadataInJson);
}
return(result);
}
