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);
}
}
}
}
private void VerifyAtomBeDisabledQueryTest(string uri)
{
var message = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + uri, UriKind.Absolute));
message.SetHeader("Accept", MimeTypes.ApplicationAtomXml);
var responseMessage = message.GetResponse();
Assert.AreEqual(415, responseMessage.StatusCode);
using (var messageReader = new ODataMessageReader(responseMessage))
{
var error = messageReader.ReadError();
Assert.AreEqual(typeof(Microsoft.OData.ODataError), error.GetType());
Assert.AreEqual("UnsupportedMediaType", error.ErrorCode);
}
}
public void AnnotationComputedOptimisticConcurrency()
{
var requestMessage = new HttpWebRequestMessage(
new DataServiceClientRequestMessageArgs(
"GET",
new Uri(this.ServiceBaseUri.OriginalString + "$metadata", UriKind.Absolute),
true,
false,
new Dictionary <string, string>()));
using (var r = new StreamReader(requestMessage.GetResponse().GetStream()))
{
var modelStr = r.ReadToEnd();
Assert.Contains("<Annotation Term=\"Org.OData.Core.V1.Computed\" Bool=\"true\" />", modelStr, StringComparison.Ordinal);
Assert.Contains("<Annotation Term=\"Org.OData.Core.V1.OptimisticConcurrency\">", modelStr, StringComparison.Ordinal);
}
}
public void MetadataShouldContainDerivedType()
{
var requestMessage = new HttpWebRequestMessage(
new DataServiceClientRequestMessageArgs(
"GET",
new Uri(this.ServiceBaseUri.OriginalString + "$metadata", UriKind.Absolute),
true,
false,
new Dictionary <string, string>()));
using (var r = new StreamReader(requestMessage.GetResponse().GetStream()))
{
var modelStr = r.ReadToEnd();
Assert.Contains("<EntityType Name=\"Manager\" BaseType=\"Microsoft.OData.Service.Sample.Trippin.Models.Person\">", modelStr, StringComparison.Ordinal);
Assert.Contains("<EntityType Name=\"Employee\" BaseType=\"Microsoft.OData.Service.Sample.Trippin.Models.Person\">", modelStr, StringComparison.Ordinal);
}
}
/// <summary>
/// Stores the metadata document from the test service as an IEdmModel
/// </summary>
private void RetrieveServiceEdmModel()
{
HttpWebRequestMessage message = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "$metadata", UriKind.Absolute));
message.SetHeader("Accept", MimeTypes.ApplicationXml);
using (var messageReader = new ODataMessageReader(message.GetResponse()))
{
Func <Uri, XmlReader> getReferencedSchemaFunc = uri =>
{
return(XmlReader.Create(GetStreamFromUrl(uri.AbsoluteUri)));
};
Model = messageReader.ReadMetadataDocument(getReferencedSchemaFunc);
}
//$metadata request failed
Assert.NotNull(Model.EntityContainer);
}
public void InvokeActionWithEnumParameterAndReturnType()
{
var writerSettings = new ODataMessageWriterSettings();
writerSettings.PayloadBaseUri = ServiceBaseUri;
var readerSettings = new ODataMessageReaderSettings();
readerSettings.BaseUri = ServiceBaseUri;
foreach (var mimeType in mimeTypes)
{
if (mimeType == MimeTypes.ApplicationAtomXml)
{
continue;
}
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri + "Products(5)/Microsoft.Test.OData.Services.ODataWCFService.AddAccessRight"));
requestMessage.SetHeader("Content-Type", mimeType);
requestMessage.SetHeader("Accept", "*/*");
requestMessage.Method = "POST";
ODataEnumValue accessRight = new ODataEnumValue("Read,Execute", NameSpacePrefix + "AccessLevel");
using (var messageWriter = new ODataMessageWriter(requestMessage, writerSettings, Model))
{
var odataWriter = messageWriter.CreateODataParameterWriter((IEdmOperation)null);
odataWriter.WriteStart();
odataWriter.WriteValue("accessRight", accessRight);
odataWriter.WriteEnd();
}
// send the http request
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var userAccessPropertyValue = messageReader.ReadProperty();
ODataEnumValue enumValue = userAccessPropertyValue.Value as ODataEnumValue;
Assert.AreEqual("Read, Execute", enumValue.Value);
}
}
}
}
public void ModelReferenceWithSelectOption()
{
Dictionary <string, int> testCases = new Dictionary <string, int>()
{
{ "Trucks('Key1')?$select=Key,FuelLevel", 2 },
{ "DerivedVehicleGPSSet('VehicleKey4')?$select=DisplayName,Map,StartLocation", 3 },
{ "VehicleGPSSetInGPS('DerivedVehicleGPSInGPSKey3')/Microsoft.OData.SampleService.Models.ModelRefDemo.TruckDemo.DerivedVehicleGPSType?$select=DisplayName,Map,StartLocation", 3 }
};
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.Equal(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
List <ODataResource> entries = new List <ODataResource>();
var reader = messageReader.CreateODataResourceReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
entries.Add(reader.Item as ODataResource);
}
}
Assert.Equal(ODataReaderState.Completed, reader.State);
Assert.Equal(testCase.Value, entries.Last().Properties.Count() + entries.Count - 1 /*non-ComplexP + ComplexP*/);
}
}
}
}
}
public void PostDeleteTypeInReferencingModel()
{
var entryWrapper = CreateVehicleGPS(true);
#region Create and Delete
var settings = new ODataMessageWriterSettings();
settings.BaseUri = ServiceBaseUri;
var vehicleGPSType = Model.FindType(TestModelNameSpace + ".GPS.VehicleGPSType") as IEdmEntityType;
var vehicleGPSSet = Model.FindEntityContainer(TestModelNameSpace + ".GPS.GPSContainer").FindEntitySet("VehicleGPSSetInGPS");
foreach (var mimeType in mimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri + "VehicleGPSSetInGPS"));
requestMessage.SetHeader("Content-Type", mimeType);
requestMessage.SetHeader("Accept", mimeType);
requestMessage.Method = "POST";
using (var messageWriter = new ODataMessageWriter(requestMessage, settings, Model))
{
var odataWriter = messageWriter.CreateODataResourceWriter(vehicleGPSSet, vehicleGPSType);
ODataWriterHelper.WriteResource(odataWriter, entryWrapper);
}
// send the http request
var responseMessage = requestMessage.GetResponse();
// Verify Created
Assert.AreEqual(201, responseMessage.StatusCode);
ODataResource entry = this.QueryEntityItem("VehicleGPSSetInGPS('000')") as ODataResource;
Assert.AreEqual("000", entry.Properties.Single(p => p.Name == "Key").Value);
// Delete the entry
var deleteRequestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri + "VehicleGPSSetInGPS('000')"));
deleteRequestMessage.Method = "DELETE";
var deleteResponseMessage = deleteRequestMessage.GetResponse();
// Verift Deleted
Assert.AreEqual(204, deleteResponseMessage.StatusCode);
ODataResource deletedEntry = this.QueryEntityItem("VehicleGPSSetInGPS('000')", 204) as ODataResource;
Assert.IsNull(deletedEntry);
}
#endregion
}
public async Task <IEnumerable <T> > ExecuteAsyncInternal <T>(Uri uri, string httpMethod, bool singleResult, Stream stream, params OperationParameter[] operationParameters)
{
try
{
if (stream != null)
{
Configurations.RequestPipeline.OnMessageCreating = args =>
{
args.Headers.Remove("Content-Length");
var msg = new HttpWebRequestMessage(args);
Task.Factory.FromAsync <Stream>(msg.BeginGetRequestStream, msg.EndGetRequestStream, null)
.ContinueWith(s => stream.CopyTo(s.Result))
.Wait();
return(msg);
};
}
return(await Task.Factory.FromAsync <IEnumerable <T> >(
(callback, state) =>
BeginExecute <T>(uri, callback, state, httpMethod, singleResult, operationParameters),
EndExecute <T>,
TaskCreationOptions.None));
}
catch (Exception ex)
{
var newException = ProcessException(ex);
if (newException != null)
{
throw newException;
}
throw;
}
finally
{
if (stream != null)
{
Configurations.RequestPipeline.OnMessageCreating = null;
}
}
}
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);
}
}
}
internal DataServiceClientRequestMessage ShimDataServiceRequest(DataServiceClientRequestMessageArgs args)
{
DataServiceClientRequestMessage message = null;
if (_dataServiceHandler != null)
{
message = _dataServiceHandler(args);
}
else
{
message = new HttpWebRequestMessage(args);
}
// apply proxy and credential settings on the core web request
InitializeMessage(message);
return(message);
}
public void QueryWithOrderByTime()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in mimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Orders?$OrderBy=ShipTime", UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.Equal(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
var list = new List <ODataResource>();
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var reader = messageReader.CreateODataResourceSetReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
ODataResource entry = reader.Item as ODataResource;
if (entry != null)
{
foreach (ODataResource pre in list)
{
TimeOfDay entryTimeOfDay = (TimeOfDay)entry.Properties.Single(p => p.Name == "ShipTime").Value;
TimeOfDay preTimeOfDay = (TimeOfDay)pre.Properties.Single(p => p.Name == "ShipTime").Value;
Assert.True(preTimeOfDay > entryTimeOfDay);
}
list.Add(entry);
}
}
}
Assert.Equal(ODataReaderState.Completed, reader.State);
}
}
}
}
public void UpdateEntityInstanceProperty()
{
// query an entry
ODataResource customerEntry = this.QueryEntityItem("Customers(1)") as ODataResource;
Assert.AreEqual("London", customerEntry.Properties.Single(p => p.Name == "City").Value);
// send a request to update an entry property
customerEntry = new ODataResource()
{
TypeName = NameSpacePrefix + "Customer"
};
customerEntry.Properties = new[] { new ODataProperty {
Name = "City", Value = "Seattle"
} };
var settings = new ODataMessageWriterSettings();
settings.BaseUri = ServiceBaseUri;
var customerType = Model.FindDeclaredType(NameSpacePrefix + "Customer") as IEdmEntityType;
var customerSet = Model.EntityContainer.FindEntitySet("Customers");
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri + "Customers(1)"));
requestMessage.SetHeader("Content-Type", MimeTypes.ApplicationJson);
requestMessage.SetHeader("Accept", MimeTypes.ApplicationJson);
requestMessage.Method = "PATCH";
using (var messageWriter = new ODataMessageWriter(requestMessage, settings))
{
var odataWriter = messageWriter.CreateODataResourceWriter(customerSet, customerType);
odataWriter.WriteStart(customerEntry);
odataWriter.WriteEnd();
}
var responseMessage = requestMessage.GetResponse();
// verify the update
Assert.AreEqual(204, responseMessage.StatusCode);
ODataResource updatedCustomer = this.QueryEntityItem("Customers(1)") as ODataResource;
Assert.AreEqual("Seattle", updatedCustomer.Properties.Single(p => p.Name == "City").Value);
}
public void PostAndQuerySingleBinaryProperty()
{
var person = new Person
{
Picture = new byte[] { 3, 1, 4 },
};
this.TestClientContext.AddToPeople(person);
this.TestClientContext.SaveChanges();
var requestMessage =
new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "People(" + person.Id + ")/Picture", UriKind.Absolute));
var responseMessage = requestMessage.GetResponse();
Assert.Equal(200, responseMessage.StatusCode);
var dat = new StreamReader(responseMessage.GetStream()).ReadToEnd();
Assert.True(dat.Contains("\"value\":\"3-1-4\""));
}
public void QueryWithAvroError()
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Products(-9)", UriKind.Absolute));
requestMessage.SetHeader("Accept", "avro/binary");
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(404, responseMessage.StatusCode);
ODataError error;
using (var reader = new ODataMessageReader(responseMessage, GetAvroReaderSettings()))
{
error = reader.ReadError();
}
Assert.IsNotNull(error);
Assert.AreEqual("NotFound", error.ErrorCode);
Assert.AreEqual("An server side error occured.", error.Message);
}
public void PropertyDefinedInReferencedModel()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
var requestMessage = new HttpWebRequestMessage(
new Uri(ServiceBaseUri.AbsoluteUri + "DerivedVehicleGPSSet('VehicleKey4')/Microsoft.OData.SampleService.Models.ModelRefDemo.GPS.VehicleGPSType/StartLocation", UriKind.Absolute));
requestMessage.SetHeader("Accept", MimeTypes.ApplicationJson + MimeTypes.ODataParameterFullMetadata);
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
messageReader.ReadProperty();
}
}
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);
}
}
}
}
}
protected void TestPostPayloadContains(string uriStringAfterServiceRoot, string expectedSubString)
{
var requestMessage = new HttpWebRequestMessage(
new DataServiceClientRequestMessageArgs(
"POST",
new Uri(this.ServiceBaseUri, uriStringAfterServiceRoot),
useDefaultCredentials: true,
usePostTunneling: false,
headers: new Dictionary <string, string>()
{
{ "Content-Length", "0" }
}));
using (var r = new StreamReader(requestMessage.GetResponse().GetStream()))
{
var payloadString = r.ReadToEnd();
Assert.Contains(expectedSubString, payloadString);
}
}
public void TopLevelComplexTypeInstanceAnnotation()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in TestMimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "People(1)/HomeAddress", UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
requestMessage.SetHeader("Prefer", string.Format("{0}={1}", IncludeAnnotation, "*"));
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var odataReader = messageReader.CreateODataResourceReader();
ODataResource resource = null;
while (odataReader.Read())
{
if (odataReader.State == ODataReaderState.ResourceEnd)
{
resource = odataReader.Item as ODataResource;
}
}
// Verify Annotation on Complex Type
ODataInstanceAnnotation annotationOnHomeAddress = resource.InstanceAnnotations
.SingleOrDefault(annotation => annotation.Name.Equals(string.Format("{0}.AddressType", TestModelNameSpace)));
Assert.AreEqual("Home", (annotationOnHomeAddress.Value as ODataPrimitiveValue).Value);
// TODO : Fix #625
//// Verify Annotation on Property in Complex Type
//ODataInstanceAnnotation annotationOnCity = complexValue.Properties.SingleOrDefault(p => p.Name.Equals("City")).InstanceAnnotations.SingleOrDefault();
//Assert.AreEqual(string.Format("{0}.CityInfo", TestModelNameSpace), annotationOnCity.Name);
//Assert.AreEqual(2, (annotationOnCity.Value as ODataComplexValue).Properties.Count());
}
}
}
}
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);
}
}
}
}
private List <ODataResource> QueryFeed(string uri, string mimeType, params string[] entryTypeNames)
{
List <ODataResource> entries = new List <ODataResource>();
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + uri, 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.CreateODataResourceSetReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
ODataResource entry = reader.Item as ODataResource;
if (entry != null && (entryTypeNames.Length == 0 || entryTypeNames.Any(e => entry.TypeName.Contains(e))))
{
entries.Add(entry);
}
}
else if (reader.State == ODataReaderState.ResourceSetEnd)
{
Assert.IsNotNull(reader.Item as ODataResourceSet);
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
}
return(entries);
}
private void SendRequestAndVerifyResponse(Dictionary <string, int> testCases)
{
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))
{
ODataEntry entry = null;
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var reader = messageReader.CreateODataFeedReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
entry = reader.Item as ODataEntry;
}
else if (reader.State == ODataReaderState.FeedEnd)
{
Assert.IsNotNull(reader.Item as ODataFeed);
}
}
}
Assert.IsNotNull(entry);
Assert.AreEqual(testCase.Value, entry.Properties.Single(p => p.Name == "PersonID").Value,
String.Format("Mime:{0},URL:{1}", mimeType, testCase.Key));
}
}
}
}
public void ValidMetadata()
{
var message = new HttpWebRequestMessage(new Uri(ServiceUri + "$metadata"));
message.SetHeader("Accept", MimeTypes.ApplicationXml);
using (var messageReader = new ODataMessageReader(message.GetResponse()))
{
var model = messageReader.ReadMetadataDocument();
var container = model.EntityContainer;
var entities = container.Elements.Where(e => e is IEdmEntitySet).ToArray();
// Verify all the entities are exposed
Assert.AreEqual(21, entities.Count(e => e.Name.StartsWith("EF")));
Assert.IsTrue(entities.All(e => e.Name.StartsWith("EF")));
// Verify all the service operation are exposed
var functions = container.Elements.Where(e => e is IEdmOperationImport).ToArray();
Assert.AreEqual(3, functions.Count());
}
}
public void FunctionReturnTime()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Orders(7)/Microsoft.Test.OData.Services.ODataWCFService.GetShipTime", UriKind.Absolute));
requestMessage.SetHeader("Accept", "*/*");
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var time = messageReader.ReadProperty().Value;
Assert.AreEqual(new TimeOfDay(12, 40, 5, 50), time);
}
}
public void BoundFunctionInReferencedModel()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "VehicleGPSSet('VehicleKey2')/Microsoft.OData.SampleService.Models.ModelRefDemo.GPS.GetVehicleSpeed()", UriKind.Absolute));
requestMessage.SetHeader("Accept", "*/*");
var responseMessage = requestMessage.GetResponse();
Assert.Equal(200, responseMessage.StatusCode);
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var amount = messageReader.ReadProperty().Value;
Assert.Equal((double)120, amount);
}
}
public void FunctionWithTime()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Orders(7)/Microsoft.Test.OData.Services.ODataWCFService.CheckShipTime(time = 12:40:5.5)", UriKind.Absolute));
requestMessage.SetHeader("Accept", "*/*");
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var isTrue = messageReader.ReadProperty().Value;
Assert.AreEqual(false, isTrue);
}
}
public void QueryPropertyValueWithTypeDefinition()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "People(1)/LastName/$value", UriKind.Absolute));
requestMessage.SetHeader("Accept", "*/*");
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var lastNameValue = messageReader.ReadValue(EdmCoreModel.Instance.GetString(false));
Assert.AreEqual("Cat", lastNameValue);
}
}
public void InvokeFunctionBoundedToSingleton()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Company/Microsoft.Test.OData.Services.ODataWCFService.GetEmployeesCount()", UriKind.Absolute));
requestMessage.SetHeader("Accept", "*/*");
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var amount = messageReader.ReadProperty().Value;
Assert.AreEqual(2, amount);
}
}
public void QueryDollarValue()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "People(1)/Home/$value", UriKind.Absolute));
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
object property = null;
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
property = messageReader.ReadValue(new EdmStringTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.String), true));
}
Assert.AreEqual("SRID=4326;POINT (23.1 32.1)", property);
}
public void QueryEnumPropertyValue()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Products(5)/SkinColor/$value", UriKind.Absolute));
requestMessage.SetHeader("Accept", "*/*");
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var skinColorPropertyValue = messageReader.ReadValue(EdmCoreModel.Instance.GetString(false));
Assert.AreEqual("Red", skinColorPropertyValue);
}
}
