public void OrderFeedTest()
{
foreach (var mimeType in this.mimeTypes)
{
var settings = new ODataMessageWriterSettings();
settings.ODataUri = new ODataUri()
{
ServiceRoot = this.ServiceUri
};
string outputWithModel = null;
string outputWithoutModel = null;
var responseMessageWithModel = new StreamResponseMessage(new MemoryStream());
responseMessageWithModel.SetHeader("Content-Type", mimeType);
using (var messageWriter = new ODataMessageWriter(responseMessageWithModel, settings, WritePayloadHelper.Model))
{
var odataWriter = messageWriter.CreateODataFeedWriter(WritePayloadHelper.OrderSet, WritePayloadHelper.OrderType);
outputWithModel = this.WriteAndVerifyOrderFeed(responseMessageWithModel, odataWriter, true, mimeType);
}
var responseMessageWithoutModel = new StreamResponseMessage(new MemoryStream());
responseMessageWithoutModel.SetHeader("Content-Type", mimeType);
using (var messageWriter = new ODataMessageWriter(responseMessageWithoutModel, settings))
{
var odataWriter = messageWriter.CreateODataFeedWriter();
outputWithoutModel = this.WriteAndVerifyOrderFeed(responseMessageWithoutModel, odataWriter, false,
mimeType);
}
WritePayloadHelper.VerifyPayloadString(outputWithModel, outputWithoutModel, mimeType);
}
}
private string WriteAndVerifyCarEntry(StreamResponseMessage responseMessage, ODataWriter odataWriter,
bool hasModel, string mimeType)
{
var carEntry = WritePayloadHelper.CreateCarEntry(hasModel);
odataWriter.WriteStart(carEntry);
// Finish writing the entry.
odataWriter.WriteEnd();
// Some very basic verification for the payload.
bool verifyEntryCalled = false;
Action <ODataEntry> verifyEntry = (entry) =>
{
Assert.AreEqual(4, entry.Properties.Count(), "entry.Properties.Count");
Assert.IsNotNull(entry.MediaResource, "entry.MediaResource");
Assert.IsTrue(entry.EditLink.AbsoluteUri.Contains("Car(11)"), "entry.EditLink");
Assert.IsTrue(entry.ReadLink == null || entry.ReadLink.AbsoluteUri.Contains("Car(11)"), "entry.ReadLink");
Assert.AreEqual(1, entry.InstanceAnnotations.Count, "entry.InstanceAnnotations.Count");
verifyEntryCalled = true;
};
Stream stream = responseMessage.GetStream();
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
stream.Seek(0, SeekOrigin.Begin);
WritePayloadHelper.ReadAndVerifyFeedEntryMessage(false, responseMessage, WritePayloadHelper.CarSet, WritePayloadHelper.CarType, null, verifyEntry,
null);
Assert.IsTrue(verifyEntryCalled, "Verification action not called.");
}
return(WritePayloadHelper.ReadStreamContent(stream));
}
public void CarEntryTest()
{
foreach (var mimeType in this.mimeTypes)
{
var settings = new ODataMessageWriterSettings();
settings.ODataUri = new ODataUri()
{
ServiceRoot = this.ServiceUri
};
string outputWithModel = null;
string outputWithoutModel = null;
var responseMessageWithModel = new StreamResponseMessage(new MemoryStream());
responseMessageWithModel.SetHeader("Content-Type", mimeType);
responseMessageWithModel.PreferenceAppliedHeader().AnnotationFilter = "*";
using (var messageWriter = new ODataMessageWriter(responseMessageWithModel, settings, WritePayloadHelper.Model))
{
var odataWriter = messageWriter.CreateODataEntryWriter(WritePayloadHelper.CarSet, WritePayloadHelper.CarType);
outputWithModel = this.WriteAndVerifyCarEntry(responseMessageWithModel, odataWriter, true, mimeType);
}
var responseMessageWithoutModel = new StreamResponseMessage(new MemoryStream());
responseMessageWithoutModel.SetHeader("Content-Type", mimeType);
responseMessageWithoutModel.PreferenceAppliedHeader().AnnotationFilter = "*";
using (var messageWriter = new ODataMessageWriter(responseMessageWithoutModel, settings))
{
var odataWriter = messageWriter.CreateODataEntryWriter();
outputWithoutModel = this.WriteAndVerifyCarEntry(responseMessageWithoutModel, odataWriter, false,
mimeType);
}
WritePayloadHelper.VerifyPayloadString(outputWithModel, outputWithoutModel, mimeType);
}
}
private string WriteAndVerifySingleLink(StreamResponseMessage responseMessage, ODataMessageWriter messageWriter, string mimeType)
{
var link = new ODataEntityReferenceLink()
{
Url = new Uri(this.ServiceUri + "Order(-10)")
};
messageWriter.WriteEntityReferenceLink(link);
var stream = responseMessage.GetStream();
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
stream.Seek(0, SeekOrigin.Begin);
var settings = new ODataMessageReaderSettings()
{
BaseUri = this.ServiceUri
};
ODataMessageReader messageReader = new ODataMessageReader(responseMessage, settings, WritePayloadHelper.Model);
ODataEntityReferenceLink linkRead = messageReader.ReadEntityReferenceLink();
Assert.IsTrue(linkRead.Url.AbsoluteUri.Contains("Order(-10)"), "linkRead.Url");
}
return(WritePayloadHelper.ReadStreamContent(stream));
}
public void SpecifySerializationInfoForFeedAndEntry()
{
foreach (var mimeType in this.testMimeTypes)
{
var settings = new ODataMessageWriterSettings();
settings.ODataUri = new ODataUri()
{
ServiceRoot = this.ServiceUri
};
var responseMessageWithoutModel = new StreamResponseMessage(new MemoryStream());
responseMessageWithoutModel.SetHeader("Content-Type", mimeType);
using (var messageWriter = new ODataMessageWriter(responseMessageWithoutModel, settings))
{
var odataWriter = messageWriter.CreateODataFeedWriter();
var feed = this.CreatePersonFeed();
feed.SetSerializationInfo(new ODataFeedAndEntrySerializationInfo()
{
NavigationSourceName = "Person", NavigationSourceEntityTypeName = NameSpace + "Person"
});
var entry = new ODataEntry()
{
Id = new Uri(ServiceUri + "Person(-5)"),
TypeName = NameSpace + "Employee"
};
var personEntryP1 = new ODataProperty {
Name = "PersonId", Value = -5
};
var personEntryP2 = new ODataProperty
{
Name = "Name",
Value = "xhsdckkeqzvlnprheujeycqrglfehtdocildrequohlffazfgtvmddyqsaxrojqxrsckohrakdxlrghgmzqnyruzu"
};
var personEntryP3 = new ODataProperty {
Name = "ManagersPersonId", Value = -465010984
};
entry.Properties = new[] { personEntryP1, personEntryP2, personEntryP3 };
entry.SetSerializationInfo(new ODataFeedAndEntrySerializationInfo()
{
NavigationSourceName = "Person", NavigationSourceEntityTypeName = NameSpace + "Person"
});
odataWriter.WriteStart(feed);
odataWriter.WriteStart(entry);
odataWriter.WriteEnd();
odataWriter.WriteEnd();
Stream stream = responseMessageWithoutModel.GetStream();
string result = WritePayloadHelper.ReadStreamContent(stream);
Assert.IsTrue(result.Contains(NameSpace + "Employee"));
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
Assert.IsTrue(result.Contains("$metadata#Person"));
}
}
}
}
/// <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 <ODataResourceSet> verifyFeed, Action <ODataResource> verifyEntry,
Action <ODataNestedResourceInfo> verifyNavigation)
{
var settings = new ODataMessageReaderSettings()
{
BaseUri = ServiceUri
};
settings.ShouldIncludeAnnotation = s => true;
ODataMessageReader messageReader = new ODataMessageReader(responseMessage, settings, Model);
ODataReader reader = isFeed
? messageReader.CreateODataResourceSetReader(expectedSet, expectedType)
: messageReader.CreateODataResourceReader(expectedSet, expectedType);
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.ResourceSetEnd:
{
if (verifyFeed != null)
{
verifyFeed((ODataResourceSet)reader.Item);
}
break;
}
case ODataReaderState.ResourceEnd:
{
if (verifyEntry != null && reader.Item != null)
{
verifyEntry((ODataResource)reader.Item);
}
break;
}
case ODataReaderState.NestedResourceInfoEnd:
{
if (verifyNavigation != null)
{
verifyNavigation((ODataNestedResourceInfo)reader.Item);
}
break;
}
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
private ODataMessageWriter CreateODataMessageWriter(StreamResponseMessage responseMessage, ODataMessageWriterSettings settings, bool hasModel)
{
if (hasModel)
{
return(new ODataMessageWriter(responseMessage, settings, WritePayloadHelper.Model));
}
else
{
return(new ODataMessageWriter(responseMessage, settings));
}
}
public void EmployeeEntryTest()
{
foreach (var mimeType in this.mimeTypes)
{
var settings = new ODataMessageWriterSettings()
{
PayloadBaseUri = this.ServiceUri
};
settings.ODataUri = new ODataUri()
{
ServiceRoot = this.ServiceUri
};
string outputWithTypeCast = null;
string outputWithoutTypeCast = null;
// employee entry as response of person(1)
var responseMessageWithoutTypeCast = new StreamResponseMessage(new MemoryStream());
responseMessageWithoutTypeCast.SetHeader("Content-Type", mimeType);
using (var messageWriter = new ODataMessageWriter(responseMessageWithoutTypeCast, settings))
{
var odataWriter = messageWriter.CreateODataEntryWriter();
outputWithoutTypeCast = this.WriteAndVerifyEmployeeEntry(responseMessageWithoutTypeCast, odataWriter,
false, mimeType);
}
// employee entry as response of person(1)/EmployeeTyeName, in this case the test sets ExpectedTypeName as Employee in Serialization info
var responseMessageWithTypeCast = new StreamResponseMessage(new MemoryStream());
responseMessageWithTypeCast.SetHeader("Content-Type", mimeType);
using (var messageWriter = new ODataMessageWriter(responseMessageWithTypeCast, settings))
{
var odataWriter = messageWriter.CreateODataEntryWriter();
outputWithTypeCast = this.WriteAndVerifyEmployeeEntry(responseMessageWithTypeCast, odataWriter, true,
mimeType);
}
if (mimeType.Contains(MimeTypes.ODataParameterMinimalMetadata) || mimeType.Contains(MimeTypes.ODataParameterFullMetadata))
{
// expect type cast in odata.metadata if EntitySetElementTypeName != ExpectedTypeName
Assert.IsTrue(outputWithoutTypeCast.Contains(this.ServiceUri + "$metadata#Person/$entity"));
Assert.IsTrue(
outputWithTypeCast.Contains(this.ServiceUri + "$metadata#Person/" + NameSpace +
"Employee/$entity"));
}
if (mimeType.Contains(MimeTypes.ApplicationJsonLight))
{
// write odata.type if entry TypeName != ExpectedTypeName
Assert.IsTrue(outputWithoutTypeCast.Contains("odata.type"));
Assert.IsFalse(outputWithTypeCast.Contains("odata.type"));
}
}
}
private string ReadFeedEntryMessage(bool isFeed, StreamResponseMessage responseMessage, string mimeType, IEdmEntitySet edmEntitySet, IEdmEntityType edmEntityType)
{
Stream stream = responseMessage.GetStream();
stream.Seek(0, SeekOrigin.Begin);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
// read the response message using ODL reader, verify the read completed successfully
WritePayloadHelper.ReadAndVerifyFeedEntryMessage(isFeed, responseMessage, edmEntitySet, edmEntityType, null, null, null);
}
return(WritePayloadHelper.ReadStreamContent(stream));
}
public void PersonFeedTest()
{
foreach (var mimeType in this.mimeTypes)
{
var settings = new ODataMessageWriterSettings()
{
PayloadBaseUri = this.ServiceUri
};
settings.ODataUri = new ODataUri()
{
ServiceRoot = this.ServiceUri
};
string outputWithModel = null;
string outputWithoutModel = null;
var responseMessageWithModel = new StreamResponseMessage(new MemoryStream());
responseMessageWithModel.SetHeader("Content-Type", mimeType);
using (var messageWriter = new ODataMessageWriter(responseMessageWithModel, settings, WritePayloadHelper.Model))
{
var odataWriter = messageWriter.CreateODataFeedWriter(WritePayloadHelper.PersonSet, WritePayloadHelper.PersonType);
outputWithModel = this.WriteAndVerifyPersonFeed(responseMessageWithModel, odataWriter, true,
mimeType);
}
var responseMessageWithoutModel = new StreamResponseMessage(new MemoryStream());
responseMessageWithoutModel.SetHeader("Content-Type", mimeType);
using (var messageWriter = new ODataMessageWriter(responseMessageWithoutModel, settings))
{
var odataWriter = messageWriter.CreateODataFeedWriter();
outputWithoutModel = this.WriteAndVerifyPersonFeed(responseMessageWithoutModel, odataWriter, false,
mimeType);
}
WritePayloadHelper.VerifyPayloadString(outputWithModel, outputWithoutModel, mimeType);
if (mimeType.Contains(MimeTypes.ODataParameterMinimalMetadata) || mimeType.Contains(MimeTypes.ODataParameterFullMetadata))
{
Assert.IsTrue(outputWithoutModel.Contains(this.ServiceUri + "$metadata#Person\""));
}
if (mimeType.Contains(MimeTypes.ApplicationJsonLight))
{
// odata.type is included in json light payload only if entry typename is different than serialization info
Assert.IsFalse(outputWithoutModel.Contains("{\"@odata.type\":\"" + "#" + NameSpace + "Person\","), "odata.type Person");
Assert.IsTrue(outputWithoutModel.Contains("{\"@odata.type\":\"" + "#" + NameSpace + "Employee\","), "odata.type Employee");
Assert.IsTrue(outputWithoutModel.Contains("{\"@odata.type\":\"" + "#" + NameSpace + "SpecialEmployee\","), "odata.type SpecialEmployee");
}
}
}
public void HandCraftEdmType()
{
foreach (var mimeType in this.testMimeTypes)
{
EdmModel edmModel = new EdmModel();
EdmEntityType edmEntityType = new EdmEntityType(NameSpace, "Person");
edmModel.AddElement(edmEntityType);
var keyProperty = new EdmStructuralProperty(edmEntityType, "PersonId", EdmCoreModel.Instance.GetInt32(false));
edmEntityType.AddKeys(new IEdmStructuralProperty[] { keyProperty });
edmEntityType.AddProperty(keyProperty);
var property = new EdmStructuralProperty(edmEntityType, "Name", EdmCoreModel.Instance.GetString(true));
edmEntityType.AddKeys(new IEdmStructuralProperty[] { property });
edmEntityType.AddProperty(property);
var defaultContainer = new EdmEntityContainer(NameSpace, "DefaultContainer");
edmModel.AddElement(defaultContainer);
EdmEntitySet entitySet = new EdmEntitySet(defaultContainer, "Person", edmEntityType);
defaultContainer.AddElement(entitySet);
var settings = new ODataMessageWriterSettings();
settings.ODataUri = new ODataUri()
{
ServiceRoot = this.ServiceUri
};
var responseMessageWithoutModel = new StreamResponseMessage(new MemoryStream());
responseMessageWithoutModel.SetHeader("Content-Type", mimeType);
using (var messageWriter = new ODataMessageWriter(responseMessageWithoutModel, settings))
{
var odataWriter = messageWriter.CreateODataEntryWriter(entitySet, edmEntityType);
var entry = this.CreatePersonEntryWithoutSerializationInfo();
string expectedError = null;
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
expectedError = "ODataFeedAndEntryTypeContext_MetadataOrSerializationInfoMissing";
}
AssertThrows <ODataException>(
() =>
{
odataWriter.WriteStart(entry);
odataWriter.WriteEnd();
},
expectedError);
}
}
}
private string WriteAndVerifyCollection(StreamResponseMessage responseMessage, ODataCollectionWriter odataWriter,
bool hasModel, string mimeType)
{
var collectionStart = new ODataCollectionStart()
{
Name = "BackupContactInfo", Count = 12, NextPageLink = new Uri("http://localhost")
};
if (!hasModel)
{
collectionStart.SetSerializationInfo(new ODataCollectionStartSerializationInfo()
{
CollectionTypeName = "Collection(" + NameSpace + "ContactDetails)"
});
}
odataWriter.WriteStart(collectionStart);
odataWriter.WriteItem(WritePayloadHelper.CreatePrimaryContactODataComplexValue());
odataWriter.WriteEnd();
Stream stream = responseMessage.GetStream();
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
stream.Seek(0, SeekOrigin.Begin);
var settings = new ODataMessageReaderSettings()
{
BaseUri = this.ServiceUri
};
ODataMessageReader messageReader = new ODataMessageReader(responseMessage, settings, WritePayloadHelper.Model);
ODataCollectionReader reader = messageReader.CreateODataCollectionReader(WritePayloadHelper.ContactDetailType);
bool collectionRead = false;
while (reader.Read())
{
if (reader.State == ODataCollectionReaderState.CollectionEnd)
{
collectionRead = true;
}
}
Assert.IsTrue(collectionRead, "collectionRead");
Assert.AreEqual(ODataCollectionReaderState.Completed, reader.State);
}
return(WritePayloadHelper.ReadStreamContent(stream));
}
public void HandCraftEdmType()
{
foreach (var mimeType in this.testMimeTypes)
{
EdmModel edmModel = new EdmModel();
EdmEntityType edmEntityType = new EdmEntityType(NameSpace, "Person");
edmModel.AddElement(edmEntityType);
var keyProperty = new EdmStructuralProperty(edmEntityType, "PersonId", EdmCoreModel.Instance.GetInt32(false));
edmEntityType.AddKeys(new IEdmStructuralProperty[] { keyProperty });
edmEntityType.AddProperty(keyProperty);
var property = new EdmStructuralProperty(edmEntityType, "Name", EdmCoreModel.Instance.GetString(true));
edmEntityType.AddKeys(new IEdmStructuralProperty[] { property });
edmEntityType.AddProperty(property);
var defaultContainer = new EdmEntityContainer(NameSpace, "DefaultContainer");
edmModel.AddElement(defaultContainer);
EdmEntitySet entitySet = new EdmEntitySet(defaultContainer, "Person", edmEntityType);
defaultContainer.AddElement(entitySet);
var settings = new ODataMessageWriterSettings();
settings.ODataUri = new ODataUri()
{
ServiceRoot = this.ServiceUri
};
var responseMessageWithoutModel = new StreamResponseMessage(new MemoryStream());
responseMessageWithoutModel.SetHeader("Content-Type", mimeType);
using (var messageWriter = new ODataMessageWriter(responseMessageWithoutModel, settings))
{
var odataWriter = messageWriter.CreateODataResourceWriter(entitySet, edmEntityType);
var entry = this.CreatePersonEntryWithoutSerializationInfo();
odataWriter.WriteStart(entry);
odataWriter.WriteEnd();
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
Assert.IsTrue(
WritePayloadHelper.ReadStreamContent(responseMessageWithoutModel.GetStream())
.Contains("Person/$entity"));
}
}
}
}
public void SingleLinkTest()
{
foreach (var mimeType in this.mimeTypes)
{
string testMimeType = mimeType.Contains("xml") ? MimeTypes.ApplicationXml : mimeType;
var settings = new ODataMessageWriterSettings();
settings.ODataUri = new ODataUri()
{
ServiceRoot = this.ServiceUri
};
var responseMessage = new StreamResponseMessage(new MemoryStream());
responseMessage.SetHeader("Content-Type", testMimeType);
using (var messageWriter = new ODataMessageWriter(responseMessage, settings, WritePayloadHelper.Model))
{
this.WriteAndVerifySingleLink(responseMessage, messageWriter, testMimeType);
}
}
}
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 WriteAndVerifyLinks(StreamResponseMessage responseMessage, ODataMessageWriter messageWriter, string mimeType)
{
var links = new ODataEntityReferenceLinks()
{
Links = new[]
{
new ODataEntityReferenceLink()
{
Url = new Uri(this.ServiceUri + "Order(-10)")
},
new ODataEntityReferenceLink()
{
Url = new Uri(this.ServiceUri + "Order(-7)")
},
},
NextPageLink = new Uri(this.ServiceUri + "Customer(-10)/Orders/$ref?$skiptoken=-7")
};
messageWriter.WriteEntityReferenceLinks(links);
Stream stream = responseMessage.GetStream();
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
stream.Seek(0, SeekOrigin.Begin);
var settings = new ODataMessageReaderSettings()
{
BaseUri = this.ServiceUri
};
ODataMessageReader messageReader = new ODataMessageReader(responseMessage, settings, WritePayloadHelper.Model);
ODataEntityReferenceLinks linksRead = messageReader.ReadEntityReferenceLinks();
Assert.AreEqual(2, linksRead.Links.Count(), "linksRead.Links.Count");
Assert.IsNotNull(linksRead.NextPageLink, "linksRead.NextPageLink");
}
return(WritePayloadHelper.ReadStreamContent(stream));
}
public void CompileAndVerifyGeneratedCode()
{
TestServiceUtil.ServiceUriGenerator = new ServiceUriGenerator();
foreach (var descriptor in TestServiceDescriptors)
{
var serviceWrapper = new DefaultServiceWrapper(descriptor.Value);
try
{
serviceWrapper.StartService();
var edmx = RetrieveServiceModelEdmx(serviceWrapper.ServiceUri);
Assert.IsNotNull(edmx);
// retrieve the IEdmModel corresponding with the edmx
byte[] byteArray = Encoding.UTF8.GetBytes(edmx);
var message = new StreamResponseMessage(new MemoryStream(byteArray));
message.SetHeader("Content-Type", MimeTypes.ApplicationXml);
IEdmModel model = null;
using (var messageReader = new ODataMessageReader(message))
{
model = messageReader.ReadMetadataDocument();
}
foreach (var languageOption in languageOptions)
{
foreach (var useDataServiceCollection in useDataServiceCollectionBools)
{
var generatedCode = this.Generate(edmx, descriptor.Key, languageOption, useDataServiceCollection);
this.CompileAndVerify(generatedCode, languageOption == ODataT4CodeGenerator.LanguageOption.CSharp, model);
}
}
}
finally
{
serviceWrapper.StopService();
}
}
}
public void CollectionTest()
{
foreach (var mimeType in this.mimeTypes)
{
string testMimeType = mimeType.Contains("xml") ? MimeTypes.ApplicationXml : mimeType;
var settings = new ODataMessageWriterSettings()
{
PayloadBaseUri = this.ServiceUri
};
settings.ODataUri = new ODataUri()
{
ServiceRoot = this.ServiceUri
};
string outputWithModel = null;
string outputWithoutModel = null;
var responseMessageWithModel = new StreamResponseMessage(new MemoryStream());
responseMessageWithModel.SetHeader("Content-Type", testMimeType);
using (var messageWriter = new ODataMessageWriter(responseMessageWithModel, settings, WritePayloadHelper.Model))
{
var odataWriter = messageWriter.CreateODataCollectionWriter(WritePayloadHelper.ContactDetailType);
outputWithModel = this.WriteAndVerifyCollection(responseMessageWithModel, odataWriter, true,
testMimeType);
}
var responseMessageWithoutModel = new StreamResponseMessage(new MemoryStream());
responseMessageWithoutModel.SetHeader("Content-Type", testMimeType);
using (var messageWriter = new ODataMessageWriter(responseMessageWithoutModel, settings))
{
var odataWriter = messageWriter.CreateODataCollectionWriter();
outputWithoutModel = this.WriteAndVerifyCollection(responseMessageWithoutModel, odataWriter, false,
testMimeType);
}
Assert.AreEqual(outputWithModel, outputWithoutModel);
}
}
public void ChangeSerializationInfoAfterWriteStart()
{
foreach (var mimeType in this.testMimeTypes)
{
var settings = new ODataMessageWriterSettings();
settings.ODataUri = new ODataUri()
{
ServiceRoot = this.ServiceUri
};
var responseMessageWithoutModel = new StreamResponseMessage(new MemoryStream());
responseMessageWithoutModel.SetHeader("Content-Type", mimeType);
using (var messageWriter = new ODataMessageWriter(responseMessageWithoutModel, settings))
{
var odataWriter = messageWriter.CreateODataResourceWriter();
var entry = this.CreatePersonEntryWithoutSerializationInfo();
entry.SetSerializationInfo(new ODataResourceSerializationInfo()
{
NavigationSourceName = "Person", NavigationSourceEntityTypeName = NameSpace + "Person"
});
odataWriter.WriteStart(entry);
entry.SetSerializationInfo(new ODataResourceSerializationInfo()
{
NavigationSourceName = "Parsen", NavigationSourceEntityTypeName = NameSpace + "Person"
});
odataWriter.WriteEnd();
Stream stream = responseMessageWithoutModel.GetStream();
// nometadata option does not write odata.metadata in the payload
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
Assert.IsTrue(WritePayloadHelper.ReadStreamContent(stream).Contains("Person/$entity"));
}
}
}
}
public void WriteEntryWithWrongSerializationInfoWithModel()
{
bool[] autoComputeMetadataBools = new bool[] { true, false, };
foreach (var mimeType in this.testMimeTypes)
{
foreach (var autoComputeMetadata in autoComputeMetadataBools)
{
var settings = new ODataMessageWriterSettings();
settings.ODataUri = new ODataUri()
{
ServiceRoot = this.ServiceUri
};
settings.AutoComputePayloadMetadataInJson = autoComputeMetadata;
var responseMessageWithoutModel = new StreamResponseMessage(new MemoryStream());
responseMessageWithoutModel.SetHeader("Content-Type", mimeType);
using (var messageWriter = new ODataMessageWriter(responseMessageWithoutModel, settings, WritePayloadHelper.Model))
{
var odataWriter = messageWriter.CreateODataEntryWriter(WritePayloadHelper.PersonSet, WritePayloadHelper.PersonType);
var entry = this.CreatePersonEntryWithoutSerializationInfo();
entry.SetSerializationInfo(new ODataFeedAndEntrySerializationInfo()
{
NavigationSourceName = "Parsen", NavigationSourceEntityTypeName = NameSpace + "Person"
});
odataWriter.WriteStart(entry);
odataWriter.WriteEnd();
var result = WritePayloadHelper.ReadStreamContent(responseMessageWithoutModel.GetStream());
Assert.IsTrue(result.Contains("\"PersonId\":-5"));
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
// no metadata does not write odata.metadata
Assert.IsTrue(result.Contains("$metadata#Parsen/$entity"));
}
}
}
}
}
public void LinksTest()
{
foreach (var mimeType in this.mimeTypes)
{
if (mimeType.Equals(MimeTypes.ApplicationXml))
{
continue;
}
string testMimeType = mimeType;
var settings = new ODataMessageWriterSettings();
settings.ODataUri = new ODataUri()
{
ServiceRoot = this.ServiceUri
};
var responseMessage = new StreamResponseMessage(new MemoryStream());
responseMessage.SetHeader("Content-Type", testMimeType);
using (var messageWriter = new ODataMessageWriter(responseMessage, settings, WritePayloadHelper.Model))
{
this.WriteAndVerifyLinks(responseMessage, messageWriter, testMimeType);
}
}
}
public void ExpandedCustomerEntryTest()
{
foreach (var mimeType in this.mimeTypes)
{
var settings = new ODataMessageWriterSettings();
settings.ODataUri = new ODataUri()
{
ServiceRoot = this.ServiceUri
};
string outputWithModel = null;
string outputWithoutModel = null;
var responseMessageWithModel = new StreamResponseMessage(new MemoryStream());
responseMessageWithModel.SetHeader("Content-Type", mimeType);
using (var messageWriter = new ODataMessageWriter(responseMessageWithModel, settings, WritePayloadHelper.Model))
{
var odataWriter = messageWriter.CreateODataEntryWriter(WritePayloadHelper.CustomerSet, WritePayloadHelper.CustomerType);
outputWithModel = this.WriteAndVerifyExpandedCustomerEntry(responseMessageWithModel, odataWriter,
true, mimeType);
}
var responseMessageWithoutModel = new StreamResponseMessage(new MemoryStream());
responseMessageWithoutModel.SetHeader("Content-Type", mimeType);
using (var messageWriter = new ODataMessageWriter(responseMessageWithoutModel, settings))
{
var odataWriter = messageWriter.CreateODataEntryWriter();
outputWithoutModel = this.WriteAndVerifyExpandedCustomerEntry(responseMessageWithoutModel,
odataWriter, false, mimeType);
}
if (mimeType != MimeTypes.ApplicationAtomXml)
{
WritePayloadHelper.VerifyPayloadString(outputWithModel, outputWithoutModel, mimeType);
}
}
}
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 WriteAndVerifyEmployeeEntry(StreamResponseMessage responseMessage, ODataWriter odataWriter,
bool hasExpectedType, string mimeType)
{
ODataEntry employeeEntry = WritePayloadHelper.CreateEmployeeEntry(false);
ODataFeedAndEntrySerializationInfo serializationInfo = new ODataFeedAndEntrySerializationInfo()
{
NavigationSourceName = "Person",
NavigationSourceEntityTypeName = NameSpace + "Person",
};
if (hasExpectedType)
{
serializationInfo.ExpectedTypeName = NameSpace + "Employee";
}
employeeEntry.SetSerializationInfo(serializationInfo);
odataWriter.WriteStart(employeeEntry);
var employeeNavigation1 = new ODataNavigationLink()
{
Name = "PersonMetadata",
IsCollection = true,
Url = new Uri("Person(-3)/" + NameSpace + "Employee" + "/PersonMetadata", UriKind.Relative)
};
odataWriter.WriteStart(employeeNavigation1);
odataWriter.WriteEnd();
var employeeNavigation2 = new ODataNavigationLink()
{
Name = "Manager",
IsCollection = false,
Url = new Uri("Person(-3)/" + NameSpace + "Employee" + "/Manager", UriKind.Relative)
};
odataWriter.WriteStart(employeeNavigation2);
odataWriter.WriteEnd();
// Finish writing employeeEntry.
odataWriter.WriteEnd();
// Some very basic verification for the payload.
bool verifyEntryCalled = false;
bool verifyNavigationCalled = false;
Action <ODataEntry> verifyEntry = (entry) =>
{
Assert.IsTrue(entry.EditLink.AbsoluteUri.Contains("Person"), "entry.EditLink");
verifyEntryCalled = true;
};
Action <ODataNavigationLink> verifyNavigation = (navigation) =>
{
Assert.IsTrue(navigation.Name == "PersonMetadata" || navigation.Name == "Manager", "navigation.Name");
verifyNavigationCalled = true;
};
Stream stream = responseMessage.GetStream();
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
stream.Seek(0, SeekOrigin.Begin);
WritePayloadHelper.ReadAndVerifyFeedEntryMessage(false, responseMessage, WritePayloadHelper.PersonSet, WritePayloadHelper.PersonType, null,
verifyEntry, verifyNavigation);
Assert.IsTrue(verifyEntryCalled && verifyNavigationCalled,
"Verification action not called.");
}
return(WritePayloadHelper.ReadStreamContent(stream));
}
private string WriteAndVerifyPersonFeed(StreamResponseMessage responseMessage, ODataWriter odataWriter,
bool hasModel, string mimeType)
{
var personFeed = new ODataFeed()
{
Id = new Uri(this.ServiceUri + "Person"),
DeltaLink = new Uri(this.ServiceUri + "Person")
};
if (!hasModel)
{
personFeed.SetSerializationInfo(new ODataFeedAndEntrySerializationInfo()
{
NavigationSourceName = "Person", NavigationSourceEntityTypeName = NameSpace + "Person"
});
}
odataWriter.WriteStart(personFeed);
ODataEntry personEntry = WritePayloadHelper.CreatePersonEntry(hasModel);
odataWriter.WriteStart(personEntry);
var personNavigation = new ODataNavigationLink()
{
Name = "PersonMetadata",
IsCollection = true,
Url = new Uri("Person(-5)/PersonMetadata", UriKind.Relative)
};
odataWriter.WriteStart(personNavigation);
odataWriter.WriteEnd();
// Finish writing personEntry.
odataWriter.WriteEnd();
ODataEntry employeeEntry = WritePayloadHelper.CreateEmployeeEntry(hasModel);
odataWriter.WriteStart(employeeEntry);
var employeeNavigation1 = new ODataNavigationLink()
{
Name = "PersonMetadata",
IsCollection = true,
Url = new Uri("Person(-3)/" + NameSpace + "Employee" + "/PersonMetadata", UriKind.Relative)
};
odataWriter.WriteStart(employeeNavigation1);
odataWriter.WriteEnd();
var employeeNavigation2 = new ODataNavigationLink()
{
Name = "Manager",
IsCollection = false,
Url = new Uri("Person(-3)/" + NameSpace + "Employee" + "/Manager", UriKind.Relative)
};
odataWriter.WriteStart(employeeNavigation2);
odataWriter.WriteEnd();
// Finish writing employeeEntry.
odataWriter.WriteEnd();
ODataEntry specialEmployeeEntry = WritePayloadHelper.CreateSpecialEmployeeEntry(hasModel);
odataWriter.WriteStart(specialEmployeeEntry);
var specialEmployeeNavigation1 = new ODataNavigationLink()
{
Name = "PersonMetadata",
IsCollection = true,
Url = new Uri("Person(-10)/" + NameSpace + "SpecialEmployee" + "/PersonMetadata", UriKind.Relative)
};
odataWriter.WriteStart(specialEmployeeNavigation1);
odataWriter.WriteEnd();
var specialEmployeeNavigation2 = new ODataNavigationLink()
{
Name = "Manager",
IsCollection = false,
Url = new Uri("Person(-10)/" + NameSpace + "SpecialEmployee" + "/Manager", UriKind.Relative)
};
odataWriter.WriteStart(specialEmployeeNavigation2);
odataWriter.WriteEnd();
var specialEmployeeNavigation3 = new ODataNavigationLink()
{
Name = "Car",
IsCollection = false,
Url = new Uri("Person(-10)/" + NameSpace + "SpecialEmployee" + "/Manager", UriKind.Relative)
};
odataWriter.WriteStart(specialEmployeeNavigation3);
odataWriter.WriteEnd();
// Finish writing specialEmployeeEntry.
odataWriter.WriteEnd();
// Finish writing the feed.
odataWriter.WriteEnd();
// Some very basic verification for the payload.
bool verifyFeedCalled = false;
bool verifyEntryCalled = false;
bool verifyNavigationCalled = false;
Action <ODataFeed> verifyFeed = (feed) =>
{
if (mimeType != MimeTypes.ApplicationAtomXml)
{
Assert.IsTrue(feed.DeltaLink.AbsoluteUri.Contains("Person"));
}
verifyFeedCalled = true;
};
Action <ODataEntry> verifyEntry = (entry) =>
{
Assert.IsTrue(entry.EditLink.AbsoluteUri.EndsWith("Person(-5)") ||
entry.EditLink.AbsoluteUri.EndsWith("Person(-3)/" + NameSpace + "Employee") ||
entry.EditLink.AbsoluteUri.EndsWith("Person(-10)/" + NameSpace + "SpecialEmployee"));
verifyEntryCalled = true;
};
Action <ODataNavigationLink> verifyNavigation = (navigation) =>
{
Assert.IsTrue(navigation.Name == "PersonMetadata" || navigation.Name == "Manager" || navigation.Name == "Car");
verifyNavigationCalled = true;
};
Stream stream = responseMessage.GetStream();
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
stream.Seek(0, SeekOrigin.Begin);
WritePayloadHelper.ReadAndVerifyFeedEntryMessage(true, responseMessage, WritePayloadHelper.PersonSet, WritePayloadHelper.PersonType, verifyFeed,
verifyEntry, verifyNavigation);
Assert.IsTrue(verifyFeedCalled && verifyEntryCalled && verifyNavigationCalled,
"Verification action not called.");
}
return(WritePayloadHelper.ReadStreamContent(stream));
}
private string WriteAndVerifyExpandedCustomerEntry(StreamResponseMessage responseMessage,
ODataWriter odataWriter, bool hasModel, string mimeType)
{
ODataEntry customerEntry = WritePayloadHelper.CreateCustomerEntry(hasModel);
odataWriter.WriteStart(customerEntry);
// write non-expanded navigations
foreach (var navigation in WritePayloadHelper.CreateCustomerNavigationLinks())
{
odataWriter.WriteStart(navigation);
odataWriter.WriteEnd();
}
// write expanded navigation
var expandedNavigation = new ODataNavigationLink()
{
Name = "Logins",
IsCollection = true,
Url = new Uri(this.ServiceUri + "Customer(-9)/Logins")
};
odataWriter.WriteStart(expandedNavigation);
var loginFeed = new ODataFeed()
{
Id = new Uri(this.ServiceUri + "Customer(-9)/Logins")
};
if (!hasModel)
{
loginFeed.SetSerializationInfo(new ODataFeedAndEntrySerializationInfo()
{
NavigationSourceName = "Login", NavigationSourceEntityTypeName = NameSpace + "Login"
});
}
odataWriter.WriteStart(loginFeed);
var loginEntry = WritePayloadHelper.CreateLoginEntry(hasModel);
odataWriter.WriteStart(loginEntry);
foreach (var navigation in WritePayloadHelper.CreateLoginNavigationLinks())
{
odataWriter.WriteStart(navigation);
odataWriter.WriteEnd();
}
// Finish writing loginEntry.
odataWriter.WriteEnd();
// Finish writing the loginFeed.
odataWriter.WriteEnd();
// Finish writing expandedNavigation.
odataWriter.WriteEnd();
// Finish writing customerEntry.
odataWriter.WriteEnd();
// Some very basic verification for the payload.
bool verifyFeedCalled = false;
int verifyEntryCalled = 0;
bool verifyNavigationCalled = false;
Action <ODataFeed> verifyFeed = (feed) =>
{
verifyFeedCalled = true;
};
Action <ODataEntry> verifyEntry = (entry) =>
{
if (entry.TypeName.Contains("Customer"))
{
Assert.AreEqual(7, entry.Properties.Count());
}
if (entry.TypeName.Contains("Login"))
{
Assert.AreEqual(2, entry.Properties.Count());
}
verifyEntryCalled++;
};
Action <ODataNavigationLink> verifyNavigation = (navigation) =>
{
Assert.IsNotNull(navigation.Name);
verifyNavigationCalled = true;
};
Stream stream = responseMessage.GetStream();
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
stream.Seek(0, SeekOrigin.Begin);
WritePayloadHelper.ReadAndVerifyFeedEntryMessage(false, responseMessage, WritePayloadHelper.CustomerSet, WritePayloadHelper.CustomerType,
verifyFeed, verifyEntry, verifyNavigation);
Assert.IsTrue(verifyFeedCalled && verifyEntryCalled == 2 && verifyNavigationCalled,
"Verification action not called.");
}
return(WritePayloadHelper.ReadStreamContent(stream));
}
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 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);
}
private string WriteAndVerifyOrderFeed(StreamResponseMessage responseMessage, ODataWriter odataWriter,
bool hasModel, string mimeType)
{
var orderFeed = new ODataFeed()
{
Id = new Uri(this.ServiceUri + "Order"),
NextPageLink = new Uri(this.ServiceUri + "Order?$skiptoken=-9"),
};
if (!hasModel)
{
orderFeed.SetSerializationInfo(new ODataFeedAndEntrySerializationInfo()
{
NavigationSourceName = "Order", NavigationSourceEntityTypeName = NameSpace + "Order"
});
}
odataWriter.WriteStart(orderFeed);
var orderEntry1 = WritePayloadHelper.CreateOrderEntry1(hasModel);
odataWriter.WriteStart(orderEntry1);
var orderEntry1Navigation1 = new ODataNavigationLink()
{
Name = "Customer",
IsCollection = false,
Url = new Uri(this.ServiceUri + "Order(-10)/Customer")
};
odataWriter.WriteStart(orderEntry1Navigation1);
odataWriter.WriteEnd();
var orderEntry1Navigation2 = new ODataNavigationLink()
{
Name = "Login",
IsCollection = false,
Url = new Uri(this.ServiceUri + "Order(-10)/Login")
};
odataWriter.WriteStart(orderEntry1Navigation2);
odataWriter.WriteEnd();
// Finish writing orderEntry1.
odataWriter.WriteEnd();
var orderEntry2 = WritePayloadHelper.CreateOrderEntry2(hasModel);
odataWriter.WriteStart(orderEntry2);
var orderEntry2Navigation1 = new ODataNavigationLink()
{
Name = "Customer",
IsCollection = false,
Url = new Uri(this.ServiceUri + "Order(-9)/Customer")
};
odataWriter.WriteStart(orderEntry2Navigation1);
odataWriter.WriteEnd();
var orderEntry2Navigation2 = new ODataNavigationLink()
{
Name = "Login",
IsCollection = false,
Url = new Uri(this.ServiceUri + "Order(-9)/Login")
};
odataWriter.WriteStart(orderEntry2Navigation2);
odataWriter.WriteEnd();
// Finish writing orderEntry2.
odataWriter.WriteEnd();
// Finish writing the feed.
odataWriter.WriteEnd();
// Some very basic verification for the payload.
bool verifyFeedCalled = false;
bool verifyEntryCalled = false;
bool verifyNavigationCalled = false;
Action <ODataFeed> verifyFeed = (feed) =>
{
Assert.IsNotNull(feed.NextPageLink, "feed.NextPageLink");
verifyFeedCalled = true;
};
Action <ODataEntry> verifyEntry = (entry) =>
{
Assert.AreEqual(3, entry.Properties.Count(), "entry.Properties.Count");
verifyEntryCalled = true;
};
Action <ODataNavigationLink> verifyNavigation = (navigation) =>
{
Assert.IsTrue(navigation.Name == "Customer" || navigation.Name == "Login", "navigation.Name");
verifyNavigationCalled = true;
};
Stream stream = responseMessage.GetStream();
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
stream.Seek(0, SeekOrigin.Begin);
WritePayloadHelper.ReadAndVerifyFeedEntryMessage(true, responseMessage, WritePayloadHelper.OrderSet, WritePayloadHelper.OrderType, verifyFeed,
verifyEntry, verifyNavigation);
Assert.IsTrue(verifyFeedCalled && verifyEntryCalled && verifyNavigationCalled,
"Verification action not called.");
}
return(WritePayloadHelper.ReadStreamContent(stream));
}
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);
}
