public async Task ListOfDateTimeSerializesAsOData_CustomTimeZone()
{
// Arrange
const string expect =
"{" +
"\"@odata.context\":\"http://localhost/$metadata#Collection(Edm.DateTimeOffset)\",\"value\":[" +
"\"1978-11-14T17:12:13-08:00\",\"2014-10-27T04:25:26-08:00\"" +
"]" +
"}";
List <DateTime> listOfDateTime = new List <DateTime>();
listOfDateTime.Add(new DateTime(1978, 11, 15, 01, 12, 13, DateTimeKind.Utc));
listOfDateTime.Add(new DateTime(2014, 10, 27, 12, 25, 26, DateTimeKind.Utc));
var routeName = "OData";
var model = GetSampleModel();
var config = RoutingConfigurationFactory.CreateWithRootContainer(routeName, b => b.AddService(ServiceLifetime.Singleton, s => model));
config.SetTimeZoneInfo(TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time"));
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/property", config, routeName);
var payload = new ODataPayloadKind[] { ODataPayloadKind.Collection };
var formatter = FormatterTestHelper.GetFormatter(payload, request);
var content = FormatterTestHelper.GetContent(listOfDateTime, formatter,
ODataMediaTypes.ApplicationJsonODataMinimalMetadata);
// Act & Assert
JsonAssert.Equal(expect, await FormatterTestHelper.GetContentResult(content, request));
}
public async Task Posting_NonDerivedType_To_Action_Expecting_BaseType_Throws()
{
// Arrange
StringContent content = new StringContent("{ '@odata.type' : '#Microsoft.AspNet.OData.Test.Builder.TestModels.Motorcycle' }");
var headers = FormatterTestHelper.GetContentHeaders("application/json");
IODataRequestMessage oDataRequest = ODataMessageWrapperHelper.Create(await content.ReadAsStreamAsync(), headers);
ODataMessageReader reader = new ODataMessageReader(oDataRequest, new ODataMessageReaderSettings(), _model);
ODataDeserializerProvider deserializerProvider = ODataDeserializerProviderFactory.Create();
ODataDeserializerContext context = new ODataDeserializerContext {
Model = _model
};
IEdmActionImport action = _model.EntityContainer
.OperationImports()
.Single(f => f.Name == "PostMotorcycle_When_Expecting_Car") as IEdmActionImport;
Assert.NotNull(action);
IEdmEntitySetBase actionEntitySet;
action.TryGetStaticEntitySet(_model, out actionEntitySet);
context.Path = new ODataPath(new OperationImportSegment(new[] { action }, actionEntitySet, null));
// Act & Assert
ExceptionAssert.Throws <ODataException>(
() => new ODataResourceDeserializer(deserializerProvider).Read(reader, typeof(Car), context),
"A resource with type 'Microsoft.AspNet.OData.Test.Builder.TestModels.Motorcycle' was found, " +
"but it is not assignable to the expected type 'Microsoft.AspNet.OData.Test.Builder.TestModels.Car'. " +
"The type specified in the resource must be equal to either the expected type or a derived type.");
}
public async Task ListOfNullableDateTimeSerializesAsOData()
{
// Arrange
DateTime dt1 = new DateTime(1978, 11, 15, 01, 12, 13, DateTimeKind.Local);
DateTime dt2 = new DateTime(2014, 10, 27, 12, 25, 26, DateTimeKind.Local);
List <DateTime?> listOfDateTime = new List <DateTime?> {
dt1, null, dt2
};
var routeName = "OData";
var model = GetSampleModel();
var config = RoutingConfigurationFactory.CreateWithRootContainer(routeName, b => b.AddService(ServiceLifetime.Singleton, s => model));
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/property", config, routeName);
var payload = new ODataPayloadKind[] { ODataPayloadKind.Collection };
var formatter = FormatterTestHelper.GetFormatter(payload, request);
var content = FormatterTestHelper.GetContent(listOfDateTime, formatter,
ODataMediaTypes.ApplicationJsonODataMinimalMetadata);
// Act & Assert
dynamic result = JObject.Parse(await FormatterTestHelper.GetContentResult(content, request));
Assert.Equal(3, result["value"].Count);
DateTimeOffset?dto = (DateTimeOffset?)result["value"][0];
Assert.Equal(new DateTimeOffset(dt1), dto.Value);
dto = (DateTimeOffset?)result["value"][1];
Assert.Null(dto);
dto = (DateTimeOffset?)result["value"][2];
Assert.Equal(new DateTimeOffset(dt2), dto.Value);
}
private static async Task <IODataRequestMessage> CreateRequest(string body)
{
HttpContent content = new StringContent(body);
var headers = FormatterTestHelper.GetContentHeaders("application/json;odata.metadata=full");
return(ODataMessageWrapperHelper.Create(await content.ReadAsStreamAsync(), headers));
}
public async Task PrimitiveTypesSerializeAsOData(Type valueType, object value, string mediaType, string resourceName)
{
// Arrange
string expectedEntity = Resources.GetString(resourceName);
Assert.NotNull(expectedEntity); // Guard
ODataConventionModelBuilder modelBuilder = ODataConventionModelBuilderFactory.Create();
modelBuilder.EntitySet <WorkItem>("WorkItems");
IEdmModel model = modelBuilder.GetEdmModel();
IEdmProperty property = model.EntityContainer.EntitySets().Single().EntityType().Properties().First();
ODataPath path = new ODataPath(new PropertySegment(property as IEdmStructuralProperty));
var configuration = RoutingConfigurationFactory.CreateWithRootContainer("OData");
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/WorkItems(10)/ID", configuration, "OData", path);
var formatter = FormatterTestHelper.GetFormatter(new ODataPayloadKind[] { ODataPayloadKind.Property }, request, mediaType);
// Act
Type type = (value != null) ? value.GetType() : typeof(Nullable <int>);
var content = FormatterTestHelper.GetContent(value, type, formatter, mediaType.ToString());
string actualEntity = await FormatterTestHelper.GetContentResult(content, request);
// Assert
Assert.NotNull(valueType);
JsonAssert.Equal(expectedEntity, actualEntity);
}
public async Task NullPrimitiveValueDeserializeAsOData(Type valueType, object value, string mediaType, string resourceName)
{
// Arrange
string entity = Resources.GetString(resourceName);
Assert.NotNull(entity);
object expectedValue = value;
ODataConventionModelBuilder modelBuilder = ODataConventionModelBuilderFactory.Create();
modelBuilder.EntitySet <WorkItem>("WorkItems");
IEdmModel model = modelBuilder.GetEdmModel();
var configuration = RoutingConfigurationFactory.CreateWithRootContainer("OData", c => c.AddService(ServiceLifetime.Singleton, b => model));
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/WorkItems(10)/ID", configuration, "OData");
var formatter = FormatterTestHelper.GetInputFormatter(new ODataPayloadKind[] { ODataPayloadKind.Property }, request, mediaType);
// Act
object actualValue = await FormatterTestHelper.ReadAsync(formatter, entity, valueType, request, mediaType);
// Assert
Assert.Equal(expectedValue, actualValue);
}
public async Task ListOfDatesSerializesAsOData()
{
// Arrange
const string expect =
"{" +
"\"@odata.context\":\"http://localhost/$metadata#Collection(Edm.Date)\",\"value\":[" +
"\"0001-01-01\",\"2015-02-26\",\"9999-12-31\"" +
"]" +
"}";
List <Date> listOfDates = new List <Date>();
listOfDates.Add(Date.MinValue);
listOfDates.Add(new Date(2015, 2, 26));
listOfDates.Add(Date.MaxValue);
var routeName = "OData";
var model = GetSampleModel();
var config = RoutingConfigurationFactory.CreateWithRootContainer(routeName, b => b.AddService(ServiceLifetime.Singleton, s => model));
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/property", config, routeName);
var payload = new ODataPayloadKind[] { ODataPayloadKind.Collection };
var formatter = FormatterTestHelper.GetFormatter(payload, request);
var content = FormatterTestHelper.GetContent(listOfDates, formatter,
ODataMediaTypes.ApplicationJsonODataMinimalMetadata);
// Act & Assert
JsonAssert.Equal(expect, await FormatterTestHelper.GetContentResult(content, request));
}
public async Task ListOfNullableTimeOfDaysSerializesAsOData()
{
// Arrange
const string expect =
"{" +
"\"@odata.context\":\"http://localhost/$metadata#Collection(Edm.TimeOfDay)\",\"value\":[" +
"\"00:00:00.0000000\",\"01:02:03.0040000\",null,\"23:59:59.9999999\"" +
"]" +
"}";
List <TimeOfDay?> listOfDates = new List <TimeOfDay?>();
listOfDates.Add(TimeOfDay.MinValue);
listOfDates.Add(new TimeOfDay(1, 2, 3, 4));
listOfDates.Add(null);
listOfDates.Add(TimeOfDay.MaxValue);
var routeName = "OData";
var model = GetSampleModel();
var config = RoutingConfigurationFactory.CreateWithRootContainer(routeName, b => b.AddService(ServiceLifetime.Singleton, s => model));
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/property", config, routeName);
var payload = new ODataPayloadKind[] { ODataPayloadKind.Collection };
var formatter = FormatterTestHelper.GetFormatter(payload, request);
var content = FormatterTestHelper.GetContent(listOfDates, formatter,
ODataMediaTypes.ApplicationJsonODataMinimalMetadata);
// Act & Assert
JsonAssert.Equal(expect, await FormatterTestHelper.GetContentResult(content, request));
}
public void ResolveUrl_ReturnsOriginalUri_IfContentIdCannotBeResolved()
{
var headers = FormatterTestHelper.GetContentHeaders();
var message = ODataMessageWrapperHelper.Create(new MemoryStream(), headers);
Uri uri = message.ConvertPayloadUri(new Uri("http://localhost"), new Uri("$1", UriKind.Relative));
Assert.Equal("$1", uri.OriginalString);
}
private static IODataRequestMessage CreateRequest()
{
//HttpContentHeaders headers;
//using (HttpContent content = new StreamContent(Stream.Null))
//{
// headers = content.Headers;
//}
var headers = FormatterTestHelper.GetContentHeaders("application/json;odata.metadata=full");
return(ODataMessageWrapperHelper.Create(Stream.Null, headers));
}
public async Task ArrayOfBooleansSerializesAsOData()
{
// Arrange
var routeName = "OData";
var model = GetSampleModel();
var config = RoutingConfigurationFactory.CreateWithRootContainer(routeName, b => b.AddService(ServiceLifetime.Singleton, s => model));
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/property", config, routeName);
var payload = new ODataPayloadKind[] { ODataPayloadKind.Collection };
var formatter = FormatterTestHelper.GetFormatter(payload, request);
var content = FormatterTestHelper.GetContent(new bool[] { true, false, true, false }, formatter,
ODataMediaTypes.ApplicationJsonODataMinimalMetadata);
// Act & Assert
JsonAssert.Equal(Resources.ArrayOfBoolean, await FormatterTestHelper.GetContentResult(content, request));
}
public void ResolveUrl_ResolvesUriWithContentId()
{
Dictionary <string, string> contentIdMapping = new Dictionary <string, string>
{
{ "1", "http://localhost/values(1)" },
{ "11", "http://localhost/values(11)" },
};
var headers = FormatterTestHelper.GetContentHeaders();
var message = ODataMessageWrapperHelper.Create(new MemoryStream(), headers, contentIdMapping);
Uri uri = message.ConvertPayloadUri(new Uri("http://localhost"), new Uri("$1", UriKind.Relative));
Assert.Equal("http://localhost/values(1)", uri.OriginalString);
}
private ODataMessageWriter GetODataMessageWriter(IEdmModel model, MemoryStream bufferedStream)
{
ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings()
{
BaseUri = new Uri("http://localhost/odata"),
Version = ODataVersion.V4,
ODataUri = new ODataUri {
ServiceRoot = new Uri("http://localhost/odata")
}
};
var headers = FormatterTestHelper.GetContentHeaders("application/json");
IODataResponseMessage responseMessage = ODataMessageWrapperHelper.Create(bufferedStream, headers);
return(new ODataMessageWriter(responseMessage, writerSettings, model));
}
public async Task ComplexTypeSerializesAsOData()
{
// Arrange
string routeName = "OData";
IEdmModel model = GetSampleModel();
var config = RoutingConfigurationFactory.Create();
config = RoutingConfigurationFactory.CreateWithRootContainer(routeName, b => b.AddService(ServiceLifetime.Singleton, s => model));
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/property", config, routeName);
var payload = new ODataPayloadKind[] { ODataPayloadKind.Resource };
var formatter = FormatterTestHelper.GetFormatter(payload, request);
var content = FormatterTestHelper.GetContent(new Person(0, new ReferenceDepthContext(7)), formatter,
ODataMediaTypes.ApplicationJsonODataMinimalMetadata);
// Act & Assert
JsonAssert.Equal(Resources.PersonComplexType, await FormatterTestHelper.GetContentResult(content, request));
}
public async Task EntityTypeSerializesAsODataEntry()
{
// Arrange
const string routeName = "OData";
IEdmEntitySet entitySet = _model.EntityContainer.FindEntitySet("employees");
ODataPath path = new ODataPath(new EntitySetSegment(entitySet));
var config = RoutingConfigurationFactory.CreateWithRootContainer(routeName, b => b.AddService(ServiceLifetime.Singleton, s => _model));
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/property", config, routeName, path);
var payload = new ODataPayloadKind[] { ODataPayloadKind.Resource };
var formatter = FormatterTestHelper.GetFormatter(payload, request);
Employee employee = (Employee)TypeInitializer.GetInstance(SupportedTypes.Employee);
var content = FormatterTestHelper.GetContent(employee, formatter,
ODataMediaTypes.ApplicationJsonODataMinimalMetadata);
// Act & Assert
JsonAssert.Equal(Resources.EmployeeEntry, await FormatterTestHelper.GetContentResult(content, request));
}
public async Task IEnumerableOfEntityTypeSerializesAsODataResourceSet()
{
// Arrange
IEdmEntitySet entitySet = _model.EntityContainer.FindEntitySet("employees");
ODataPath path = new ODataPath(new EntitySetSegment(entitySet));
var request = RequestFactory.CreateFromModel(_model, "http://localhost/property", "Route", path);
var payload = new ODataPayloadKind[] { ODataPayloadKind.ResourceSet };
var formatter = FormatterTestHelper.GetFormatter(payload, request);
IEnumerable <Employee> collectionOfPerson = new Collection <Employee>()
{
(Employee)TypeInitializer.GetInstance(SupportedTypes.Employee, 0),
(Employee)TypeInitializer.GetInstance(SupportedTypes.Employee, 1),
};
var content = FormatterTestHelper.GetContent(collectionOfPerson, formatter,
ODataMediaTypes.ApplicationJsonODataMinimalMetadata);
// Act & Assert
JsonAssert.Equal(Resources.FeedOfEmployee, await FormatterTestHelper.GetContentResult(content, request));
}
public async Task ListOfStringsSerializesAsOData()
{
// Arrange
List <string> listOfStrings = new List <string>();
listOfStrings.Add("Frank");
listOfStrings.Add("Steve");
listOfStrings.Add("Tom");
listOfStrings.Add("Chandler");
var routeName = "OData";
var model = GetSampleModel();
var config = RoutingConfigurationFactory.CreateWithRootContainer(routeName, b => b.AddService(ServiceLifetime.Singleton, s => model));
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/property", config, routeName);
var payload = new ODataPayloadKind[] { ODataPayloadKind.Collection };
var formatter = FormatterTestHelper.GetFormatter(payload, request);
var content = FormatterTestHelper.GetContent(listOfStrings, formatter,
ODataMediaTypes.ApplicationJsonODataMinimalMetadata);
// Act & Assert
JsonAssert.Equal(Resources.ListOfString, await FormatterTestHelper.GetContentResult(content, request));
}
public async Task Read_ReturnsEdmComplexObjectCollection_TypelessMode()
{
// Arrange
IEdmTypeReference addressType = _model.GetEdmTypeReference(typeof(Address)).AsComplex();
IEdmCollectionTypeReference addressCollectionType =
new EdmCollectionTypeReference(new EdmCollectionType(addressType));
HttpContent content = new StringContent("{ 'value': [ {'@odata.type':'Microsoft.Test.AspNet.OData.Common.Models.Address', 'City' : 'Redmond' } ] }");
var headers = FormatterTestHelper.GetContentHeaders("application/json");
IODataRequestMessage request = ODataMessageWrapperHelper.Create(await content.ReadAsStreamAsync(), headers);
ODataMessageReader reader = new ODataMessageReader(request, new ODataMessageReaderSettings(), _model);
var deserializer = new ODataResourceSetDeserializer(_deserializerProvider);
ODataDeserializerContext readContext = new ODataDeserializerContext
{
Model = _model,
ResourceType = typeof(IEdmObject),
ResourceEdmType = addressCollectionType
};
// Act
IEnumerable result = deserializer.Read(reader, typeof(IEdmObject), readContext) as IEnumerable;
// Assert
var addresses = result.Cast <EdmComplexObject>();
Assert.NotNull(addresses);
EdmComplexObject address = Assert.Single(addresses);
Assert.Equal(new[] { "City" }, address.GetChangedPropertyNames());
object city;
Assert.True(address.TryGetPropertyValue("City", out city));
Assert.Equal("Redmond", city);
}
public async Task NullPrimitiveValueSerializeAsODataThrows(Type valueType, object value, string mediaType, string unused)
{
// Arrange
Assert.NotNull(valueType);
Assert.NotNull(unused);
ODataConventionModelBuilder modelBuilder = ODataConventionModelBuilderFactory.Create();
modelBuilder.EntitySet <WorkItem>("WorkItems");
IEdmModel model = modelBuilder.GetEdmModel();
IEdmProperty property = model.EntityContainer.EntitySets().Single().EntityType().Properties().First();
ODataPath path = new ODataPath(new PropertySegment(property as IEdmStructuralProperty));
var configuration = RoutingConfigurationFactory.CreateWithRootContainer("OData");
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/WorkItems(10)/ID", configuration, "OData", path);
var formatter = FormatterTestHelper.GetFormatter(new ODataPayloadKind[] { ODataPayloadKind.Property }, request, mediaType);
// Act & Assert
Type type = (value != null) ? value.GetType() : typeof(Nullable <int>);
var content = FormatterTestHelper.GetContent(value, type, formatter, mediaType.ToString());
await ExceptionAssert.ThrowsAsync <ODataException>(
() => FormatterTestHelper.GetContentResult(content, request),
"Cannot write the value 'null' in top level property; return 204 instead.");
}
