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))
{
var odatareader = messageReader.CreateODataResourceReader();
while (odatareader.Read())
{
if (odatareader.State == ODataReaderState.ResourceEnd)
{
Assert.IsNotNull(odatareader.Item as ODataResource);
}
}
}
}
public void UnBoundActionForEntryInReferencedModel()
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "ResetVehicleSpeedToValue", UriKind.Absolute));
requestMessage.SetHeader("Accept", "*/*");
requestMessage.Method = "POST";
ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings()
{
BaseUri = ServiceBaseUri
};
using (var messageWriter = new ODataMessageWriter(requestMessage, writerSettings, Model))
{
var odataWriter = messageWriter.CreateODataParameterWriter(null);
odataWriter.WriteStart();
odataWriter.WriteValue("targetValue", 80);
odataWriter.WriteEnd();
}
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
var actual = (this.QueryEntityItem("VehicleGPSSetInGPS('VehicleGPSSetInGPSKey2')") as ODataResource).Properties.Single(p => p.Name == "VehicleSpeed").Value;
Assert.AreEqual((double)80, actual);
}
public void ServiceDocument()
{
string[] types = new string[]
{
MimeTypes.ApplicationJson + MimeTypes.ODataParameterFullMetadata,
MimeTypes.ApplicationJson + MimeTypes.ODataParameterMinimalMetadata,
MimeTypes.ApplicationJson + MimeTypes.ODataParameterNoMetadata,
};
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in types)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri, 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))
{
ODataServiceDocument workSpace = messageReader.ReadServiceDocument();
Assert.IsNotNull(workSpace.EntitySets.Single(c => c.Name == "Trucks"));
Assert.AreEqual("GetDefaultOutsideGeoFenceAlarm", workSpace.FunctionImports.First().Name);
}
}
}
}
public void EntryTypeDefinedInReferencedModel()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in mimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "VehicleGPSSet('VehicleKey2')", 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.CreateODataResourceReader();
List <ODataResource> entries = new List <ODataResource>();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
entries.Add(reader.Item as ODataResource);
}
}
Assert.AreEqual("VehicleKey2", entries.Last().Properties.Single(p => p.Name == "Key").Value);
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
}
}
}
private void TestGet(string relativeUri, string expectedPayload)
{
var headers = new Dictionary <string, string>
{
{ "Content-Type", "application/json" }
};
var request = new HttpWebRequestMessage(
new DataServiceClientRequestMessageArgs(
"Get",
new Uri(this.TestClientContext.BaseUri, relativeUri),
false,
false,
headers));
using (var response = request.GetResponse() as HttpWebResponseMessage)
{
Assert.Equal(200, response.StatusCode);
using (var stream = response.GetStream())
{
var reader = new StreamReader(stream);
var content = reader.ReadToEnd();
Assert.Equal(expectedPayload, content);
}
}
}
public void UnBoundFunctionReturnTypeInReferencedModel()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "GetDefaultOutsideGeoFenceAlarm()", UriKind.Absolute));
requestMessage.SetHeader("Accept", "*/*");
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
ODataResource perp = null;
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var odataReader = messageReader.CreateODataResourceReader();
while (odataReader.Read())
{
if (odataReader.State == ODataReaderState.ResourceEnd)
{
perp = odataReader.Item as ODataResource;
}
}
Assert.AreEqual(1, perp.Properties.Single(p => p.Name == "Severity").Value);
}
}
public ODataFeed QueryInnerFeed(string requestUri, string mimeType)
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = baseUri
};
var requestMessage = new HttpWebRequestMessage(new Uri(baseUri.AbsoluteUri + requestUri, UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, model))
{
var reader = messageReader.CreateODataEntryReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.FeedEnd)
{
return(reader.Item as ODataFeed);
}
}
}
}
return(null);
}
public void QueryRawValue()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Orders(7)/ShipDate/$value", UriKind.Absolute));
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var date = messageReader.ReadValue(EdmCoreModel.Instance.GetDate(false));
Assert.AreEqual(new Date(2014, 8, 31), date);
}
var requestMessage2 = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Orders(7)/ShipTime/$value", UriKind.Absolute));
var responseMessage2 = requestMessage2.GetResponse();
Assert.AreEqual(200, responseMessage2.StatusCode);
using (var messageReader = new ODataMessageReader(responseMessage2, readerSettings, Model))
{
var date = messageReader.ReadValue(EdmCoreModel.Instance.GetTimeOfDay(false));
Assert.AreEqual(new TimeOfDay(12, 40, 5, 50), date);
}
}
public void CallUnboundFunctionWhichReturnsEnumValue()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in mimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "GetDefaultColor()", UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
if (mimeType == MimeTypes.ApplicationAtomXml)
{
requestMessage.SetHeader("Accept", "text/html, application/xhtml+xml, */*");
}
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
ODataProperty colorProperty = messageReader.ReadProperty();
ODataEnumValue enumValue = colorProperty.Value as ODataEnumValue;
Assert.AreEqual("Red", enumValue.Value);
}
}
}
}
public void RequestDeltaLink_Projection()
{
var customersSet = Model.FindDeclaredEntitySet("Customers");
var cutomerType = customersSet.EntityType();
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in deltaMimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "$delta?$token=projection", 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))
{
var deltaReader = messageReader.CreateODataDeltaReader(customersSet, cutomerType);
while (deltaReader.Read())
{
if (deltaReader.State == ODataDeltaReaderState.DeltaResourceEnd)
{
ODataResource entry = deltaReader.Item as ODataResource;
}
}
Assert.Equal(ODataDeltaReaderState.Completed, deltaReader.State);
}
}
}
}
private List <ODataResource> QueryEntry(string requestUri, string mimeType)
{
List <ODataResource> entries = new List <ODataResource>();
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + requestUri, 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))
{
var reader = messageReader.CreateODataResourceReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
entries.Add(reader.Item as ODataResource);
}
}
Assert.Equal(ODataReaderState.Completed, reader.State);
}
}
return(entries);
}
public void InvokeActionWithUintParameterAndReturnType()
{
var writerSettings = new ODataMessageWriterSettings();
writerSettings.PayloadBaseUri = ServiceBaseUri;
var readerSettings = new ODataMessageReaderSettings();
readerSettings.BaseUri = ServiceBaseUri;
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri + "Products(11)/microsoft.odata.sampleService.models.typedefinition.ExtendLifeTime"));
requestMessage.SetHeader("Content-Type", MimeTypes.ApplicationJson);
requestMessage.SetHeader("Accept", MimeTypes.ApplicationJson);
requestMessage.Method = "POST";
using (var messageWriter = new ODataMessageWriter(requestMessage, writerSettings, Model))
{
var odataWriter = messageWriter.CreateODataParameterWriter((IEdmOperation)null);
odataWriter.WriteStart();
odataWriter.WriteValue("seconds", 1000u);
odataWriter.WriteEnd();
}
// send the http request
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var property = messageReader.ReadProperty();
Assert.IsNotNull(property);
Assert.AreEqual(4600ul, property.Value);
}
}
public void EntityInstanceAnnotation()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in TestMimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Boss", UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
requestMessage.SetHeader("Prefer", string.Format("{0}={1}", IncludeAnnotation, "*"));
var responseMessage = requestMessage.GetResponse();
Assert.Equal(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var reader = messageReader.CreateODataResourceReader();
List <ODataResource> entries = new List <ODataResource>();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
entries.Add(reader.Item as ODataResource);
}
}
Assert.Equal(true, (entries.Last().InstanceAnnotations.First(i => i.Name.Equals(string.Format("{0}.IsBoss", TestModelNameSpace))).Value as ODataPrimitiveValue).Value);
Assert.Equal(ODataReaderState.Completed, reader.State);
}
}
}
}
public ODataEntityReferenceLinks QueryReferenceLinks(string uri, string mimeType)
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = baseUri
};
var queryRequestMessage = new HttpWebRequestMessage(new Uri(baseUri.AbsoluteUri + uri, UriKind.Absolute));
queryRequestMessage.SetHeader("Accept", mimeType);
queryRequestMessage.SetHeader("Prefer", string.Format("{0}={1}", IncludeAnnotation, "*"));
var queryResponseMessage = queryRequestMessage.GetResponse();
Assert.AreEqual(200, queryResponseMessage.StatusCode);
ODataEntityReferenceLinks item = null;
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(queryResponseMessage, readerSettings, model))
{
item = messageReader.ReadEntityReferenceLinks();
}
}
return(item);
}
/// <summary>
/// Specifically use to query single entry or multi entries(query with $expand)
/// </summary>
/// <param name="requestUri"></param>
/// <param name="mimeType"></param>
/// <returns></returns>
public List <ODataEntry> QueryEntries(string requestUri, string mimeType)
{
List <ODataEntry> entries = new List <ODataEntry>();
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = baseUri
};
var requestMessage = new HttpWebRequestMessage(new Uri(baseUri.AbsoluteUri + requestUri, UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
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 reader = messageReader.CreateODataEntryReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
entries.Add(reader.Item as ODataEntry);
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
}
return(entries);
}
private void TestPut(string relativeUri, string payload)
{
var headers = new Dictionary <string, string>
{
{ "Content-Type", "application/json" }
};
var request = new HttpWebRequestMessage(
new DataServiceClientRequestMessageArgs(
"Put",
new Uri(this.TestClientContext.BaseUri, relativeUri),
false,
false,
headers));
using (var stream = request.GetStream())
using (var writer = new StreamWriter(stream))
{
writer.Write(payload);
}
using (var response = request.GetResponse() as HttpWebResponseMessage)
{
Assert.Equal(200, response.StatusCode);
}
}
public ODataProperty QueryProperty(string requestUri, string mimeType)
{
ODataProperty property = null;
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = baseUri
};
var requestMessage = new HttpWebRequestMessage(new Uri(baseUri.AbsoluteUri + requestUri, UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, model))
{
property = messageReader.ReadProperty();
}
}
return(property);
}
public void QueryServiceDocument()
{
string[] types = new string[]
{
"text/html, application/xhtml+xml, */*",
MimeTypes.ApplicationJson + MimeTypes.ODataParameterFullMetadata,
MimeTypes.ApplicationJson + MimeTypes.ODataParameterMinimalMetadata,
MimeTypes.ApplicationJson + MimeTypes.ODataParameterNoMetadata,
};
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in types)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri, 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))
{
ODataServiceDocument workSpace = messageReader.ReadServiceDocument();
Assert.NotNull(workSpace.EntitySets.Single(c => c.Name == "People"));
}
}
}
}
public void QueryVCardEntityProperty()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri,
};
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "People(31)/BusinessCard", UriKind.Absolute));
SetVCardMediaTypeResolver(requestMessage);
requestMessage.SetHeader("Accept", "text/x-vCard");
var responseMessage = requestMessage.GetResponse();
Assert.Equal(200, responseMessage.StatusCode);
ODataResource resource = null;
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var odataReader = messageReader.CreateODataResourceReader();
while (odataReader.Read())
{
if (odataReader.State == ODataReaderState.ResourceEnd)
{
resource = odataReader.Item as ODataResource;
}
}
}
Assert.NotNull(resource);
Assert.Equal("Name1", resource.Properties.Single(p => p.Name == "N").Value);
}
private ODataProperty QueryProperty(string requestUri, string mimeType)
{
ODataProperty property = null;
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + requestUri, UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
if (mimeType == MimeTypes.ApplicationAtomXml)
{
requestMessage.SetHeader("Accept", "text/html, application/xhtml+xml, */*");
}
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
property = messageReader.ReadProperty();
}
}
return(property);
}
public void InvokeActionBoundedToSingleton()
{
foreach (var mimeType in mimeTypes)
{
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Company/Microsoft.Test.OData.Services.ODataWCFService.IncreaseRevenue", UriKind.Absolute));
requestMessage.SetHeader("Accept", "*/*");
requestMessage.Method = "POST";
var oldProperty = this.QueryProperty("Company/Revenue", mimeType);
Int64 oldValue = (Int64)oldProperty.Value;
ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings()
{
PayloadBaseUri = ServiceBaseUri
};
using (var messageWriter = new ODataMessageWriter(requestMessage, writerSettings, Model))
{
var odataWriter = messageWriter.CreateODataParameterWriter(null);
odataWriter.WriteStart();
odataWriter.WriteValue("IncreaseValue", 20000);
odataWriter.WriteEnd();
}
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
ODataProperty property = this.QueryProperty("Company/Revenue", mimeType);
Assert.AreEqual((Int64)(oldValue + 20000), property.Value);
}
}
}
private ODataEntry QueryEntry(string uri, string mimeType)
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
var queryRequestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + uri, UriKind.Absolute));
queryRequestMessage.SetHeader("Accept", mimeType);
var queryResponseMessage = queryRequestMessage.GetResponse();
Assert.AreEqual(200, queryResponseMessage.StatusCode);
ODataEntry entry = null;
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(queryResponseMessage, readerSettings, Model))
{
var reader = messageReader.CreateODataEntryReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
entry = reader.Item as ODataEntry;
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
}
return(entry);
}
// With Web Api OData model build, max/min length is not set
// Keep this test case as Web Api is working on add max/min length support.
// [Fact]
public void AnnotationRequiredMaxMinLengthTimestamp()
{
var requestMessage = new HttpWebRequestMessage(
new DataServiceClientRequestMessageArgs(
"GET",
new Uri(this.ServiceBaseUri.OriginalString + "$metadata", UriKind.Absolute),
useDefaultCredentials: true,
usePostTunneling: false,
headers: new Dictionary <string, string>()));
using (var r = new StreamReader(requestMessage.GetResponse().GetStream()))
{
var modelStr = r.ReadToEnd();
// [Required] ==> Nullable="false"
Assert.Contains(
"<Property Name=\"FirstName\" Type=\"Edm.String\" Nullable=\"false\" MaxLength=\"max\" />",
modelStr,
StringComparison.Ordinal);
// [MaxLength] [MinLength] --> only MaxLength=".."
Assert.Contains(
"<Property Name=\"LastName\" Type=\"Edm.String\" MaxLength=\"26\" />",
modelStr,
StringComparison.Ordinal);
// [Timestamp] ==> Computed
Assert.Contains(
"<Property Name=\"TimeStampValue\" Type=\"Edm.Binary\" Nullable=\"false\" MaxLength=\"8\">\r\n"
+ " <Annotation Term=\"Org.OData.Core.V1.Computed\" Bool=\"true\" />",
modelStr,
StringComparison.Ordinal);
}
}
// [Fact] // github issuse: #896
public void TopLevelPropertyOfComplexTypeInstanceAnnotation()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in TestMimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "People(1)/HomeAddress/City", UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
requestMessage.SetHeader("Prefer", string.Format("{0}={1}", IncludeAnnotation, "*"));
var responseMessage = requestMessage.GetResponse();
Assert.Equal(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var property = messageReader.ReadProperty();
// TODO: Service does not support add annotation in property now
}
}
}
}
private void UpdateEntry(string singletonType, string singletonName, string mimeType, IEnumerable <ODataProperty> properties)
{
ODataEntry entry = new ODataEntry()
{
TypeName = NameSpacePrefix + singletonType
};
entry.Properties = properties;
var settings = new ODataMessageWriterSettings();
settings.PayloadBaseUri = ServiceBaseUri;
var customerType = Model.FindDeclaredType(NameSpacePrefix + singletonType) as IEdmEntityType;
var customerSet = Model.EntityContainer.FindSingleton(singletonName);
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri + singletonName));
requestMessage.SetHeader("Content-Type", mimeType);
requestMessage.SetHeader("Accept", mimeType);
requestMessage.Method = "PATCH";
using (var messageWriter = new ODataMessageWriter(requestMessage, settings))
{
var odataWriter = messageWriter.CreateODataEntryWriter(customerSet, customerType);
odataWriter.WriteStart(entry);
odataWriter.WriteEnd();
}
var responseMessage = requestMessage.GetResponse();
// verify the update
Assert.AreEqual(204, responseMessage.StatusCode);
}
public void QueryEntityProperty()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in mimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Customers(1)/TimeBetweenLastTwoOrders", UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
if (mimeType == MimeTypes.ApplicationAtomXml)
{
requestMessage.SetHeader("Accept", "text/html, application/xhtml+xml, */*");
}
var responseMessage = requestMessage.GetResponse();
Assert.Equal(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
ODataProperty property = null;
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
property = messageReader.ReadProperty();
}
Assert.Equal(new TimeSpan(1), property.Value);
}
}
}
public void QueryByDateKey()
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in mimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "Calendars(2015-11-11)", 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.CreateODataResourceReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
ODataResource entry = reader.Item as ODataResource;
// Verify Date Property
Assert.AreEqual(new Date(2015, 11, 11), entry.Properties.Single(p => p.Name == "Day").Value);
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
}
}
}
private ODataItem QueryEntityItem(string uri, int expectedStatusCode = 200)
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
var queryRequestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + uri, UriKind.Absolute));
queryRequestMessage.SetHeader("Accept", MimeTypes.ApplicationJsonLight);
var queryResponseMessage = queryRequestMessage.GetResponse();
Assert.AreEqual(expectedStatusCode, queryResponseMessage.StatusCode);
ODataItem item = null;
if (expectedStatusCode == 200)
{
using (var messageReader = new ODataMessageReader(queryResponseMessage, readerSettings, Model))
{
var reader = messageReader.CreateODataResourceReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
item = reader.Item;
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
}
return(item);
}
public void RequestDeltaLink_Expanded()
{
var customersSet = Model.FindDeclaredEntitySet("Customers");
var customerType = customersSet.EntityType();
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri
};
foreach (var mimeType in deltaMimeTypes)
{
var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri.AbsoluteUri + "$delta?$token=expanded", UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
// Currently don't test full metadata because the delta reader doesn't support reading
// annotations on expanded navigation properties, metadata reference properties and paging.
if (mimeType.Contains(MimeTypes.ODataParameterMinimalMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, Model))
{
var deltaReader = messageReader.CreateODataDeltaReader(customersSet, customerType);
while (deltaReader.Read())
{
if (deltaReader.State == ODataDeltaReaderState.FeedEnd)
{
Assert.IsNotNull(deltaReader.Item as ODataDeltaFeed);
}
else if (deltaReader.State == ODataDeltaReaderState.DeltaEntryEnd)
{
Assert.IsNotNull(deltaReader.Item as ODataEntry);
}
else if (deltaReader.State == ODataDeltaReaderState.ExpandedNavigationProperty)
{
switch (deltaReader.SubState)
{
case ODataReaderState.FeedEnd:
Assert.IsNotNull(deltaReader.Item as ODataFeed);
break;
case ODataReaderState.EntryEnd:
Assert.IsNotNull(deltaReader.Item as ODataEntry);
break;
case ODataReaderState.NavigationLinkEnd:
Assert.IsNotNull(deltaReader.Item as ODataNavigationLink);
break;
}
}
}
Assert.AreEqual(ODataDeltaReaderState.Completed, deltaReader.State);
}
}
}
}
public void QueryWithFormat()
{
Dictionary <string, string> testCases = new Dictionary <string, string>()
{
{ "People?$format=application/json", "application/json" },
// ODL Bug: https://github.com/OData/odata.net/issues/313
////{"People?$format=application/json;odata.metadata=full", "application/json; odata.metadata=full"},
{ "People?$format=json", "application/json" },
};
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
BaseUri = ServiceBaseUri,
UndeclaredPropertyBehaviorKinds = ODataUndeclaredPropertyBehaviorKinds.IgnoreUndeclaredValueProperty
};
foreach (var testCase in testCases)
{
DataServiceClientRequestMessageArgs args = new DataServiceClientRequestMessageArgs(
"GET",
new Uri(ServiceBaseUri.AbsoluteUri + testCase.Key, UriKind.Absolute),
false, false, new Dictionary <string, string>()
{
});
var requestMessage = new HttpWebRequestMessage(args);
using (var responseMessage = requestMessage.GetResponse() as HttpWebResponseMessage)
{
Assert.Equal(200, responseMessage.StatusCode);
string contentType = responseMessage.Headers.FirstOrDefault(x => x.Key.Equals("Content-Type")).Value;
Assert.True(contentType.StartsWith(testCase.Value));
using (var messageReader = new ODataMessageReader(
responseMessage,
readerSettings,
this.TestClientContext.Format.LoadServiceModel()))
{
var reader = messageReader.CreateODataFeedReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
ODataEntry entry = reader.Item as ODataEntry;
Assert.NotNull(entry.Properties.Single(p => p.Name == "PersonId").Value);
}
else if (reader.State == ODataReaderState.FeedEnd)
{
Assert.NotNull(reader.Item as ODataFeed);
}
}
Assert.Equal(ODataReaderState.Completed, reader.State);
}
}
}
}