public void WriteToStreamAsyncReturnsODataRepresentation()
{
ODataConventionModelBuilder modelBuilder = new ODataConventionModelBuilder();
modelBuilder.EntitySet <WorkItem>("WorkItems");
IEdmModel model = modelBuilder.GetEdmModel();
HttpConfiguration configuration = new HttpConfiguration();
configuration.EnableOData(model);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/WorkItems(10)");
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = configuration;
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = new HttpRouteData(configuration.Routes.First());
request.Properties["MS_ODataPath"] = new DefaultODataPathHandler(model).Parse("WorkItems(10)");
ODataMediaTypeFormatter formatter = CreateFormatter(model, request, ODataPayloadKind.Entry);
ObjectContent <WorkItem> content = new ObjectContent <WorkItem>((WorkItem)TypeInitializer.GetInstance(SupportedTypes.WorkItem), formatter);
RegexReplacement replaceUpdateTime = new RegexReplacement("<updated>*.*</updated>", "<updated>UpdatedTime</updated>");
Assert.Xml.Equal(BaselineResource.TestEntityWorkItem, content.ReadAsStringAsync().Result, regexReplacements: replaceUpdateTime);
}
private void ArrayOfIntsSerializesAsOData(string expectedContent, bool json)
{
ObjectContent <int[]> content = new ObjectContent <int[]>(new int[] { 10, 20, 30, 40, 50 }, _formatter,
GetMediaType(json));
AssertEqual(json, expectedContent, content.ReadAsStringAsync().Result);
}
public void WriteToStreamAsync_ReturnsCorrectBaseUri(string routePrefix, string baseUri)
{
IEdmModel model = new ODataConventionModelBuilder().GetEdmModel();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, baseUri);
HttpConfiguration configuration = new HttpConfiguration();
string routeName = "Route";
configuration.Routes.MapODataRoute(routeName, routePrefix, model);
request.SetConfiguration(configuration);
request.SetEdmModel(model);
request.SetODataPath(new ODataPath());
request.SetODataRouteName(routeName);
HttpRouteData routeData = new HttpRouteData(new HttpRoute());
routeData.Values.Add("a", "prefix");
routeData.Values.Add("b", "prefix2");
request.SetRouteData(routeData);
ODataMediaTypeFormatter formatter = CreateFormatter(model, request, ODataPayloadKind.ServiceDocument);
var content = new ObjectContent <ODataWorkspace>(new ODataWorkspace(), formatter);
string actualContent = content.ReadAsStringAsync().Result;
Assert.Contains("xml:base=\"" + baseUri + "\"", actualContent);
}
public void NullPrimitiveValueSerializeAsODataThrows(Type valueType, object value, MediaTypeHeaderValue mediaType, string notUsed)
{
ODataConventionModelBuilder modelBuilder = new ODataConventionModelBuilder();
modelBuilder.EntitySet <WorkItem>("WorkItems");
IEdmModel model = modelBuilder.GetEdmModel();
using (HttpConfiguration configuration = CreateConfiguration())
using (HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get,
"http://localhost/WorkItems(10)/ID"))
{
request.SetConfiguration(configuration);
IEdmProperty property =
model.EntityContainer.EntitySets().Single().EntityType().Properties().First();
request.ODataProperties().Path = new ODataPath(new PropertySegment(property as IEdmStructuralProperty));
request.EnableODataDependencyInjectionSupport();
ODataMediaTypeFormatter formatter = CreateFormatter(request);
formatter.SupportedMediaTypes.Add(mediaType);
Type type = (value != null) ? value.GetType() : typeof(Nullable <int>);
using (ObjectContent content = new ObjectContent(type, value, formatter))
{
Assert.Throws <ODataException>(() => content.ReadAsStringAsync().Result,
"Cannot write the value 'null' in top level property; return 204 instead.");
}
}
}
private async Task <HttpResponseMessage> PostAsJsonAsync <T>(string requestUri, T value)
{
var content = new ObjectContent <T>(value, new JsonMediaTypeFormatter());
string contentString = await content.ReadAsStringAsync();
return(await _httpClient.PostAsync(requestUri, new StringContent(contentString, Encoding.UTF8, "application/json")));
}
private string GetDataString <T>(T data)
{
using (var content = new ObjectContent(typeof(T), data, _mediaTypeFormatter))
{
return(content.ReadAsStringAsync().Result);
}
}
public void TestMethod1()
{
try
{
Task serviceTask = new Task();
serviceTask.TaskId = 1;
serviceTask.Subject = "Test Task";
serviceTask.StartDate = DateTime.Now;
serviceTask.DueDate = null;
serviceTask.CompletedDate = DateTime.Now;
serviceTask.Status = new Status
{
StatusId = 3,
Name = "Completed",
Ordinal = 2
};
serviceTask.Links = new System.Collections.Generic.List<Link>();
serviceTask.Assignees = new System.Collections.Generic.List<User>();
serviceTask.SetShouldSerializeAssignees(true);
var formatter = new JsonMediaTypeFormatter();
var content = new ObjectContent<Task>(serviceTask, formatter);
var reuslt = content.ReadAsStringAsync().Result;
}
catch(Exception ex)
{
Assert.Fail(ex.Message);
}
}
public static async Task TrackRequestBody([TimerTrigger("0 */1 * * * *")] TimerInfo myTimer,
ILogger log)
{
var accessToken = await GetAccessToken();
var client = HttpClientFactory.Create();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
var request = new TaggableItem
{
id = "0ff3ff8a-ff4a-45ef-9235-479409b5552e",
tags = new List <string> {
$"now-is-the-time|{DateTime.Now}"
}
};
var url = $"https://graph.microsoft.com/beta/applications/{request.id}";
var content = new ObjectContent <TaggableItem>(request, new JsonMediaTypeFormatter());
log.LogInformation($"Invoking {url} with body {await content.ReadAsStringAsync()}");
var result = await client.PatchAsync(url, content);
result.EnsureSuccessStatusCode();
log.LogInformation($"Received response:\r\n {await result.Content.ReadAsStringAsync()} ");
}
public void WriteToStreamAsyncReturnsODataRepresentation()
{
ODataConventionModelBuilder model = new ODataConventionModelBuilder();
model.EntitySet <WorkItem>("WorkItems");
HttpConfiguration configuration = new HttpConfiguration();
var route = configuration.Routes.MapHttpRoute(ODataRouteNames.GetById, "{controller}({id})");
configuration.Routes.MapHttpRoute(ODataRouteNames.PropertyNavigation, "{controller}({id})/{property}");
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/WorkItems(10)");
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = configuration;
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = new HttpRouteData(route);
ODataMediaTypeFormatter formatter = new ODataMediaTypeFormatter(model.GetEdmModel())
{
Request = request
};
ObjectContent <WorkItem> content = new ObjectContent <WorkItem>((WorkItem)TypeInitializer.GetInstance(SupportedTypes.WorkItem), formatter);
RegexReplacement replaceUpdateTime = new RegexReplacement("<updated>*.*</updated>", "<updated>UpdatedTime</updated>");
Assert.Xml.Equal(BaselineResource.TestEntityWorkItem, content.ReadAsStringAsync().Result, regexReplacements: replaceUpdateTime);
}
public void PrimitiveTypesSerializeAsOData(string typeString, Type valueType, object value)
{
string expected = BaselineResource.ResourceManager.GetString(typeString);
Assert.NotNull(expected);
ODataConventionModelBuilder modelBuilder = new ODataConventionModelBuilder();
modelBuilder.EntitySet <WorkItem>("WorkItems");
IEdmModel model = modelBuilder.GetEdmModel();
HttpConfiguration configuration = new HttpConfiguration();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/WorkItems(10)/ID");
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = configuration;
request.Properties["MS_ODataPath"] = new DefaultODataPathHandler(model).Parse("WorkItems(10)/ID");
ODataMediaTypeFormatter formatter = CreateFormatter(model, request);
Type type = (value != null) ? value.GetType() : typeof(Nullable <int>);
ObjectContent content = new ObjectContent(type, value, formatter);
var result = content.ReadAsStringAsync().Result;
Assert.Xml.Equal(result, expected);
}
public void GetBaseAddress_AllowsBaseAddressOverride()
{
// Arrange
string routeName = "Route";
string routePrefix = "prefix";
string baseUri = "http://localhost/prefix";
IEdmModel model = new EdmModel();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, baseUri);
HttpConfiguration configuration = new HttpConfiguration();
configuration.MapODataServiceRoute(routeName, routePrefix, model);
request.SetConfiguration(configuration);
request.ODataProperties().Path = new ODataPath();
request.EnableODataDependencyInjectionSupport(routeName);
HttpRouteData routeData = new HttpRouteData(new HttpRoute());
routeData.Values.Add("a", "prefix");
request.SetRouteData(routeData);
// Act
ODataMediaTypeFormatter formatter = CreateFormatterWithJson(model, request, ODataPayloadKind.ServiceDocument);
formatter.BaseAddressFactory = GetCustomBaseAddress;
var content = new ObjectContent <ODataServiceDocument>(new ODataServiceDocument(), formatter);
string actualContent = content.ReadAsStringAsync().Result;
// Assert
Assert.Contains("\"@odata.context\":\"https://" + CustomHost + "/" + routePrefix + "/", actualContent);
}
public void 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
};
ObjectContent <List <DateTime?> > content = new ObjectContent <List <DateTime?> >(listOfDateTime,
_formatter, ODataMediaTypes.ApplicationJsonODataMinimalMetadata);
// Act & Assert
dynamic result = JObject.Parse(content.ReadAsStringAsync().Result);
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);
}
public async Task QueueBuildAsync(string instance, string project, int buildDefinitionId, string parameters)
{
string queueBuildUrl = $"https://{instance}/defaultcollection/{project}/_apis/build/builds?api-version={apiVersion}";
Build build = new Build()
{
Definition = new BuildDefinitionRef()
{
Id = buildDefinitionId
},
Parameters = parameters
};
JsonMediaTypeFormatter formatter = new JsonMediaTypeFormatter();
formatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
ObjectContent queueBuildContent = new ObjectContent <Build>(build, formatter);
string queueBuildContentString = await queueBuildContent.ReadAsStringAsync();
HttpResponseMessage response = await client.PostAsync(queueBuildUrl, queueBuildContent);
if (!response.IsSuccessStatusCode)
{
Trace.TraceError($"Error queuing VSO build to '{queueBuildUrl}'\nBody: {queueBuildContentString}\n\nResponse StatusCode: {response.StatusCode}\nResponse Body: {await response.Content.ReadAsStringAsync()}");
}
else
{
Trace.TraceInformation($"Successfully queued VSO build.{Environment.NewLine}Response Body: {await response.Content.ReadAsStringAsync()}");
}
}
private void ArrayOfBoolsSerializesAsOData(string expectedContent, bool json)
{
ObjectContent <bool[]> content = new ObjectContent <bool[]>(new bool[] { true, false, true, false },
_formatter, GetMediaType(json));
AssertEqual(json, expectedContent, content.ReadAsStringAsync().Result);
}
private void IEnumerableOfEntityTypeSerializesAsODataFeed(string expectedContent, bool json)
{
ODataMediaTypeFormatter formatter = CreateFormatter();
IEnumerable <Employee> collectionOfPerson = new Collection <Employee>()
{
(Employee)TypeInitializer.GetInstance(SupportedTypes.Employee, 0),
(Employee)TypeInitializer.GetInstance(SupportedTypes.Employee, 1),
};
ObjectContent <IEnumerable <Employee> > content = new ObjectContent <IEnumerable <Employee> >(collectionOfPerson,
formatter, json ? ODataMediaTypes.ApplicationJsonODataMinimalMetadata :
ODataMediaTypes.ApplicationAtomXmlTypeFeed);
string actualContent = content.ReadAsStringAsync().Result;
if (json)
{
JsonAssert.Equal(expectedContent, actualContent);
}
else
{
RegexReplacement replaceUpdateTime = new RegexReplacement(
"<updated>*.*</updated>", "<updated>UpdatedTime</updated>");
Assert.Xml.Equal(expectedContent, actualContent, replaceUpdateTime);
}
}
public void WriteToStreamAsyncReturnsODataRepresentation()
{
// Arrange
ODataConventionModelBuilder modelBuilder = new ODataConventionModelBuilder();
modelBuilder.EntitySet <WorkItem>("WorkItems");
IEdmModel model = modelBuilder.GetEdmModel();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/WorkItems(10)");
HttpConfiguration configuration = new HttpConfiguration();
string routeName = "Route";
configuration.MapODataServiceRoute(routeName, null, model);
request.SetConfiguration(configuration);
IEdmEntitySet entitySet = model.EntityContainer.EntitySets().Single();
request.ODataProperties().Path = new ODataPath(new EntitySetSegment(entitySet),
new KeySegment(new[] { new KeyValuePair <string, object>("ID", 10) }, entitySet.EntityType(), entitySet));
request.EnableODataDependencyInjectionSupport(routeName);
ODataMediaTypeFormatter formatter = CreateFormatterWithJson(model, request, ODataPayloadKind.Resource);
// Act
ObjectContent <WorkItem> content = new ObjectContent <WorkItem>(
(WorkItem)TypeInitializer.GetInstance(SupportedTypes.WorkItem), formatter);
// Assert
JsonAssert.Equal(Resources.WorkItemEntry, content.ReadAsStringAsync().Result);
}
private void ComplexTypeSerializesAsOData(string expectedContent, bool json)
{
ObjectContent <Person> content = new ObjectContent <Person>(new Person(0, new ReferenceDepthContext(7)),
_formatter, CollectionTest.GetMediaType(json));
CollectionTest.AssertEqual(json, expectedContent, content.ReadAsStringAsync().Result);
}
public void ArrayOfBooleansSerializesAsOData()
{
// Arrange
ObjectContent <bool[]> content = new ObjectContent <bool[]>(new bool[] { true, false, true, false },
_formatter, ODataMediaTypes.ApplicationJsonODataMinimalMetadata);
// Act & Assert
JsonAssert.Equal(Resources.ArrayOfBoolean, content.ReadAsStringAsync().Result);
}
public void ArrayOfIntsSerializesAsOData()
{
// Arrange
ObjectContent <int[]> content = new ObjectContent <int[]>(new int[] { 10, 20, 30, 40, 50 }, _formatter,
ODataMediaTypes.ApplicationJsonODataMinimalMetadata);
// Act & Assert
JsonAssert.Equal(Resources.ArrayOfInt32, content.ReadAsStringAsync().Result);
}
public void render_template_with_embedded_layout()
{
var view = new View("Test2", new { Name = "foo" });
var content = new ObjectContent <View>(view, _formatter);
var output = content.ReadAsStringAsync().Result;
Assert.AreEqual("<html>Hello foo! Welcome to Razor!</html>", output);
}
public void render_simple_template()
{
var view = new View("Test1", new { Name = "foo" });
var content = new ObjectContent <View>(view, _formatter);
var output = content.ReadAsStringAsync().Result;
Assert.AreEqual("Hello foo! Welcome to Razor!", output);
}
public async Task GenericContentsSystemHttpContentBodyTypeAsync(object expected)
{
var content = new ObjectContent(expected.GetType(), expected).ToHttpContent();
var actual = await content.ReadAsStringAsync();
Assert.Equal(JsonConvert.SerializeObject(expected), actual);
Assert.Equal(expected, JsonConvert.DeserializeObject(actual, expected.GetType()));
}
public void ComplexTypeSerializesAsOData()
{
// Arrange
ObjectContent <Person> content = new ObjectContent <Person>(new Person(0, new ReferenceDepthContext(7)),
_formatter, ODataMediaTypes.ApplicationJsonODataMinimalMetadata);
// Act & Assert
JsonAssert.Equal(Resources.PersonComplexType, content.ReadAsStringAsync().Result);
}
public void EntityTypeSerializesAsODataEntry()
{
ODataMediaTypeFormatter formatter = CreateFormatter();
Employee employee = (Employee)TypeInitializer.GetInstance(SupportedTypes.Employee);
ObjectContent <Employee> content = new ObjectContent <Employee>(employee, formatter);
RegexReplacement replaceUpdateTime = new RegexReplacement("<updated>*.*</updated>", "<updated>UpdatedTime</updated>");
Assert.Xml.Equal(BaselineResource.TestEntityTypeBasic, content.ReadAsStringAsync().Result, regexReplacements: replaceUpdateTime);
}
/// <summary>
/// Converts the specified object to its equivalent Java Script Object Notation (JSON) form.
/// </summary>
/// <typeparam name="TObject">The <see cref="Type">type</see> of object to convert.</typeparam>
/// <param name="obj">The object to convert.</param>
/// <returns>The <paramref name="obj">object</paramref> in the JSON format.</returns>
protected async Task <string> ToJson <TObject>(TObject obj)
{
Contract.Requires(obj != null);
Contract.Ensures(Contract.Result <Task <string> >() != null);
var formatter = new JsonMediaTypeFormatter();
using (var content = new ObjectContent <TObject>(obj, formatter))
return(await content.ReadAsStringAsync());
}
public void render_template_with_specified_resolver()
{
var resolver = new EmbeddedResolver(this.GetType());
var formatter = new HtmlMediaTypeViewFormatter(null, new RazorViewLocator(), new RazorViewParser(resolver));
var view = new View("Test2", new { Name = "foo" });
var content = new ObjectContent <View>(view, formatter);
var output = content.ReadAsStringAsync().Result;
Assert.AreEqual("<html>Hello foo! Welcome to Razor!</html>", output);
}
public void EntityTypeSerializesAsODataEntry()
{
// Arrange
ODataMediaTypeFormatter formatter = CreateFormatter();
Employee employee = (Employee)TypeInitializer.GetInstance(SupportedTypes.Employee);
ObjectContent <Employee> content = new ObjectContent <Employee>(employee, formatter,
ODataMediaTypes.ApplicationJsonODataMinimalMetadata);
// Act & Assert
JsonAssert.Equal(Resources.EmployeeEntry, content.ReadAsStringAsync().Result);
}
public static void PlainTextFormatter()
{
var value = "This is a text/plain string.";
var formatter = new PlainTextBufferedFormatter();
var content = new ObjectContent <string>(value, formatter);
var result = content.ReadAsStringAsync().Result;
Helpers.AssertEquality(Helpers.__, result);
Helpers.AssertEquality("text/plain", content.Headers.ContentType.MediaType);
Helpers.AssertEquality(Helpers.__, content.Headers.ContentLength);
}
public static void XmlFormatter()
{
var person = new Person {
FirstName = "Glenn", LastName = "Block"
};
var formatter = new XmlMediaTypeFormatter();
var content = new ObjectContent <Person>(person, formatter);
var body = content.ReadAsStringAsync().Result;
Helpers.AssertEquality(Helpers.__, body);
}
public void CollectionOfComplexTypeSerializesAsOData()
{
IEnumerable <Person> collectionOfPerson = new Collection <Person>()
{
(Person)TypeInitializer.GetInstance(SupportedTypes.Person, 0),
(Person)TypeInitializer.GetInstance(SupportedTypes.Person, 1),
(Person)TypeInitializer.GetInstance(SupportedTypes.Person, 2)
};
ObjectContent <IEnumerable <Person> > content = new ObjectContent <IEnumerable <Person> >(collectionOfPerson, _formatter);
Assert.Xml.Equal(BaselineResource.TestCollectionOfPerson, content.ReadAsStringAsync().Result);
}
public void ListOfStringsSerializesAsOData()
{
List <string> listOfStrings = new List <string>();
listOfStrings.Add("Frank");
listOfStrings.Add("Steve");
listOfStrings.Add("Tom");
listOfStrings.Add("Chandler");
ObjectContent <List <string> > content = new ObjectContent <List <string> >(listOfStrings, _formatter);
Assert.Xml.Equal(BaselineResource.TestListOfStrings, content.ReadAsStringAsync().Result);
}
public void RoundTripUsingJsonNet()
{
//Arrange
var formatters = new MediaTypeFormatterCollection() {new JsonNetFormatter()};
var fromContact = new Contact { FirstName = "Brad", LastName = "Abrams" };
// Act
var fromContent = new ObjectContent<Contact>(fromContact, new MediaTypeHeaderValue("application/json"), formatters);
var contentString = fromContent.ReadAsStringAsync().Result;
var toContent = new ObjectContent<Contact>(new StringContent(contentString), formatters);
toContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var toContact = toContent.ReadAsAsync<Contact>().Result;
//Arrange
Assert.AreEqual(fromContact.FirstName, toContact.FirstName);
Assert.AreEqual(fromContact.LastName, toContact.LastName);
}
public void PrimitiveTypesSerializeAsOData(string typeString, Type valueType, object value)
{
string expected = BaselineResource.ResourceManager.GetString(typeString);
Assert.NotNull(expected);
ODataConventionModelBuilder model = new ODataConventionModelBuilder();
model.EntitySet<WorkItem>("WorkItems");
HttpConfiguration configuration = new HttpConfiguration();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/WorkItems(10)/ID");
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = configuration;
ODataMediaTypeFormatter formatter = new ODataMediaTypeFormatter(model.GetEdmModel()) { Request = request };
Type type = (value != null) ? value.GetType() : typeof(Nullable<int>);
ObjectContent content = new ObjectContent(type, value, formatter);
var result = content.ReadAsStringAsync().Result;
Assert.Xml.Equal(result, expected);
}
public HttpRequestMessage Encrypt(HttpRequestMessage plainRequest)
{
if (plainRequest == null)
{
throw new ArgumentNullException("plainMessage");
}
var plainContent = plainRequest.Content;
if (plainContent == null)
{
Trace.TraceWarning("Content of request is NULL, replace to ALTERNATIVES!");
plainContent = DefaultHttpMessageCryptoService.EmptyContentAlternatives;
}
var plain = plainContent.ReadAsByteArrayAsync().Result;
var timestamp = this.timestampProvider.GetTimestamp(); // acquire a timestamp for each request.
byte[] cipher;
string signature;
this.Encrypt(plain, timestamp, out cipher, out signature);
var cipherModel = this.CreateCipherModel(timestamp, cipher, signature);
var cipherContent = new ObjectContent(cipherModel.GetType(), cipherModel, DefaultHttpMessageCryptoService.DefaultFormatter);
Trace.TraceInformation("Encrypted request content: {0}", cipherContent.ReadAsStringAsync().Result);
plainRequest.Content = cipherContent;
plainRequest.Content.Headers.ContentType = plainContent.Headers.ContentType; // keep source content type
this.lastTimestamp = timestamp;
return plainRequest;
}
public void PrimitiveTypesSerializeAsOData(Type valueType, object value, MediaTypeHeaderValue mediaType,
string resourceName)
{
string expectedEntity = Resources.GetString(resourceName);
Assert.NotNull(expectedEntity);
ODataConventionModelBuilder modelBuilder = new ODataConventionModelBuilder();
modelBuilder.EntitySet<WorkItem>("WorkItems");
IEdmModel model = modelBuilder.GetEdmModel();
string actualEntity;
using (HttpConfiguration configuration = CreateConfiguration())
using (HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get,
"http://localhost/WorkItems(10)/ID"))
{
request.SetConfiguration(configuration);
IEdmProperty property =
model.EntityContainer.EntitySets().Single().EntityType().Properties().First();
request.ODataProperties().Model = model;
request.ODataProperties().Path = new ODataPath(new PropertyAccessPathSegment(property));
request.SetFakeODataRouteName();
ODataMediaTypeFormatter formatter = CreateFormatter(request);
formatter.SupportedMediaTypes.Add(mediaType);
Type type = (value != null) ? value.GetType() : typeof(Nullable<int>);
using (ObjectContent content = new ObjectContent(type, value, formatter))
{
actualEntity = content.ReadAsStringAsync().Result;
}
}
bool isJson = resourceName.EndsWith(".json");
if (isJson)
{
JsonAssert.Equal(expectedEntity, actualEntity);
}
else
{
Assert.Xml.Equal(expectedEntity, actualEntity);
}
}
public void SpecifyMediaTypeAndSerialize()
{
//Arrange
var content = new ObjectContent<string>("woof", "text/plain");
// This will cause the test to pass: content.Formatters.Add(new PlainTextFormatter());
//Act
var result = content.ReadAsStringAsync().Result; // Why does this change the media type of my content?
var mediaType = content.Headers.ContentType.MediaType;
//Assert
Assert.AreEqual("text/plain", mediaType); // This fails because it falls back the XmlFormatter
}
public void SpecifyMediaTypeAndSerializeAsJson()
{
//Arrange
var input = new foo { Bar = "hello" };
var content = new ObjectContent<foo>(input, "application/json");
//Act
var result = content.ReadAsStringAsync().Result;
var mediaType = content.Headers.ContentType.MediaType;
//Assert
Assert.AreEqual("application/json", mediaType);
}
public void SpecifyMediaTypeAndSerializeAsPlainTextWithACustomFormatter()
{
//Arrange
var content = new ObjectContent<string>("woof", new MediaTypeHeaderValue("text/plain"), new List<MediaTypeFormatter> { new PlainTextFormatter() });
var request = new HttpRequestMessage();
//Act
var result = content.ReadAsStringAsync().Result;
var mediaType = content.Headers.ContentType.MediaType;
//Assert
Assert.AreEqual("text/plain", mediaType);
}
public HttpResponseMessage Encrypt(HttpResponseMessage plainResponse)
{
if (plainResponse == null)
{
throw new ArgumentNullException("plainResponse");
}
var plainContent = plainResponse.Content;
if (plainContent == null)
{
Trace.TraceWarning("Content of response is NULL, replace to ALTERNATIVES!");
plainContent = DefaultHttpMessageCryptoService.EmptyContentAlternatives;
plainResponse.StatusCode = HttpStatusCode.OK;
}
var plain = plainContent.ReadAsByteArrayAsync().Result;
var timestamp = this.lastTimestamp;
byte[] cipher;
string signature;
this.Encrypt(plain, timestamp, out cipher, out signature);
var cipherModel = this.CreateCipherModel(timestamp, cipher, signature);
var cipherContent = new ObjectContent(cipherModel.GetType(), cipherModel, DefaultHttpMessageCryptoService.DefaultFormatter);
Trace.TraceInformation("Encrypted response content: {0}", cipherContent.ReadAsStringAsync().Result);
plainResponse.Content = cipherContent;
plainResponse.Content.Headers.ContentType = plainContent.Headers.ContentType;
return plainResponse;
}
