public static void AssertEntityWithSimpleProperties(EntityWithSimpleProperties actual, EntityWithSimpleProperties expected)
{
Assert.IsNotNull(actual);
Assert.AreEqual(expected.MyString, actual.MyString);
Assert.AreEqual(expected.MyBool, actual.MyBool);
Assert.AreEqual(expected.MyDateTime, actual.MyDateTime);
Assert.AreEqual(expected.MyDecimal, actual.MyDecimal);
Assert.AreEqual(expected.MyDouble, actual.MyDouble);
Assert.AreEqual(expected.MyInteger, actual.MyInteger);
}
public async Task MetadataIsCorrectForAnEntryWithJustPrimitiveTypeProperties(string acceptHeader)
{
// Arrange
EntityWithSimpleProperties entity = MetadataTestHelpers.CreateInstances <EntityWithSimpleProperties[]>()
.FirstOrDefault();
Assert.NotNull(entity);
string requestUrl = BaseAddress + "/EntityWithSimpleProperties(" + entity.Id + ")";
string expectedContextUrl = BaseAddress.ToLowerInvariant() + "/$metadata#EntityWithSimpleProperties/$entity";
// Act
var response = await Client.GetWithAcceptAsync(requestUrl, acceptHeader);
var result = await response.Content.ReadAsObject <JObject>();
// Assert
Assert.Null(result.Property("*****@*****.**"));
Assert.Null(result.Property("*****@*****.**"));
Assert.Null(result.Property("*****@*****.**"));
string doublePropertyValue = (string)result["DoubleProperty"];
if (!doublePropertyValue.Equals("INF", StringComparison.InvariantCulture) &&
!doublePropertyValue.Equals("-INF", StringComparison.InvariantCulture) &&
!doublePropertyValue.Equals("NaN", StringComparison.InvariantCulture))
{
Assert.Null(result.Property("*****@*****.**"));
}
Assert.Null(result.Property("*****@*****.**"));
if (acceptHeader.Contains("odata.metadata=none"))
{
Assert.Null(result.Property("@odata.context"));
}
else
{
ODataUrlAssert.UrlEquals(expectedContextUrl, result, "@odata.context", BaseAddress);
}
if (acceptHeader.Contains("odata.metadata=full"))
{
ODataUrlAssert.UrlEquals(requestUrl, result, "@odata.id", BaseAddress);
Assert.Equal("#Binary", result.Property("*****@*****.**").Value);
Assert.Equal("#Duration", result.Property("*****@*****.**").Value);
Assert.Equal("#Decimal", result.Property("*****@*****.**").Value);
Assert.Equal("#Single", result.Property("*****@*****.**").Value);
Assert.Equal("#Guid", result.Property("*****@*****.**").Value);
Assert.Equal("#Int16", result.Property("*****@*****.**").Value);
Assert.Equal("#Int64", result.Property("*****@*****.**").Value);
Assert.Equal("#SByte", result.Property("*****@*****.**").Value);
Assert.Equal("#DateTimeOffset", result.Property("*****@*****.**").Value);
}
}
public async Task MetadataIsCorrectForThePropertiesOfAnEntryWithJustPrimitiveTypeProperties(
string acceptHeader,
string propertyName,
string edmType)
{
// Arrange
EntityWithSimpleProperties entity = MetadataTestHelpers.CreateInstances <EntityWithSimpleProperties[]>()
.FirstOrDefault();
Assert.NotNull(entity);
string expectedContextUrl = BaseAddress + "/$metadata#EntityWithSimpleProperties(" + entity.Id + ")/" + propertyName;
string[] inferableTypes = new string[] { "Edm.Int32", "Edm.Double", "Edm.String", "Edm.Boolean" };
// Act
var entryUrl = BaseAddress + "/EntityWithSimpleProperties(" + entity.Id + ")/" + propertyName;
var response = await Client.GetWithAcceptAsync(entryUrl, acceptHeader);
var result = await response.Content.ReadAsAsync <JObject>();
bool isODataNull = result.Property("@odata.null") != null;
// Assert
if (acceptHeader.Contains("odata.metadata=none"))
{
if (!isODataNull)
{
JsonAssert.DoesNotContainProperty("@odata.*", result);
}
else
{
JsonAssert.Equals(true, (bool)result.Property("@odata.null"));
}
}
else
{
ODataUrlAssert.UrlEquals(expectedContextUrl, result, "@odata.context", BaseAddress);
if (!acceptHeader.Contains("odata.metadata=full") || (inferableTypes.Contains(edmType) && !result.IsSpecialValue()))
{
JsonAssert.DoesNotContainProperty("@odata.type", result);
}
else
{
var unqualifiedTypename = "#" + edmType.Substring(4);
JsonAssert.PropertyEquals(unqualifiedTypename, "@odata.type", result);
}
}
}
public void MetadataIsCorrectForThePropertiesOfAnEntryWithJustPrimitiveTypeProperties(string acceptHeader, string propertyName, string edmType)
{
//Arrange
EntityWithSimpleProperties[] entities = MetadataTestHelpers.CreateInstances <EntityWithSimpleProperties[]>();
EntityWithSimpleProperties entity = entities.First();
string entryUrl = BaseAddress.ToLowerInvariant() + "/EntityWithSimpleProperties(" + entity.Id + ")/" + propertyName;
HttpRequestMessage message = new HttpRequestMessage(HttpMethod.Get, entryUrl);
message.SetAcceptHeader(acceptHeader);
string expectedMetadataUrl = BaseAddress.ToLowerInvariant() + "/$metadata#" + edmType;
string[] inferableTypes = new string[] { "Edm.Int32", "Edm.Double", "Edm.String", "Edm.Boolean" };
bool isODataNull = false;
//Act
var response = Client.SendAsync(message).Result;
JObject result = response.Content.ReadAsJObject();
isODataNull = result.Property("odata.null") != null;
//Assert
if (isODataNull)
{
expectedMetadataUrl = BaseAddress.ToLowerInvariant() + "/$metadata#Edm.Null";
}
if (acceptHeader.Contains("nometadata"))
{
if (!isODataNull)
{
JsonAssert.DoesNotContainProperty("odata.*", result);
}
else
{
JsonAssert.Equals(true, (bool)result.Property("odata.null"));
}
}
else
{
JsonAssert.Equal(expectedMetadataUrl, "odata.metadata", result);
if (!acceptHeader.Contains("fullmetadata") || (inferableTypes.Contains(edmType) && !IsSpecialValue(result)))
{
JsonAssert.DoesNotContainProperty("odata.type", result);
}
else
{
JsonAssert.Equal(edmType, "odata.type", result);
}
}
}
public void MetadataIsCorrectForAnEntryWithJustPrimitiveTypeProperties(string acceptHeader)
{
//Arrange
EntityWithSimpleProperties[] entities = MetadataTestHelpers.CreateInstances <EntityWithSimpleProperties[]>();
EntityWithSimpleProperties entity = entities.First();
string requestUrl = BaseAddress.ToLowerInvariant() + "/EntityWithSimpleProperties(" + entity.Id + ")";
string expectedMetadataUrl = BaseAddress.ToLowerInvariant() + "/$metadata#EntityWithSimpleProperties/@Element";
HttpRequestMessage message = new HttpRequestMessage(HttpMethod.Get, requestUrl);
message.SetAcceptHeader(acceptHeader);
//Act
HttpResponseMessage response = Client.SendAsync(message).Result;
JObject result = response.Content.ReadAsJObject();
//Assert
JsonAssert.DoesNotContainProperty("*****@*****.**", result);
JsonAssert.DoesNotContainProperty("*****@*****.**", result);
JsonAssert.DoesNotContainProperty("*****@*****.**", result);
if (!(((string)result["DoubleProperty"]).Equals("Infinity", StringComparison.InvariantCultureIgnoreCase) ||
((string)result["DoubleProperty"]).Equals("-Infinity", StringComparison.InvariantCultureIgnoreCase) ||
((string)result["DoubleProperty"]).Equals("NaN", StringComparison.InvariantCultureIgnoreCase)))
{
JsonAssert.DoesNotContainProperty("*****@*****.**", result);
}
JsonAssert.DoesNotContainProperty("*****@*****.**", result);
if (acceptHeader.Contains("nometadata"))
{
JsonAssert.DoesNotContainProperty("odata.metadata", result);
}
else
{
JsonAssert.Equal(expectedMetadataUrl, "odata.metadata", result);
}
if (acceptHeader.Contains("fullmetadata"))
{
JsonAssert.Equal(requestUrl, "odata.id", result);
JsonAssert.Equal("Edm.Binary", "*****@*****.**", result);
JsonAssert.Equal("Edm.DateTime", "*****@*****.**", result);
JsonAssert.Equal("Edm.Decimal", "*****@*****.**", result);
JsonAssert.Equal("Edm.Single", "*****@*****.**", result);
JsonAssert.Equal("Edm.Guid", "*****@*****.**", result);
JsonAssert.Equal("Edm.Int16", "*****@*****.**", result);
JsonAssert.Equal("Edm.Int64", "*****@*****.**", result);
JsonAssert.Equal("Edm.SByte", "*****@*****.**", result);
JsonAssert.Equal("Edm.DateTimeOffset", "*****@*****.**", result);
}
}