public async Task SerializableErrorIsReturnedInExpectedFormat()
{
// Arrange
var input = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
"<Employee xmlns=\"http://schemas.datacontract.org/2004/07/FormatterWebSite\">" +
"<Id>2</Id><Name>foo</Name></Employee>";
var expectedOutput = "{\"Id\":[\"The field Id must be between 10 and 100." +
"\"],\"Name\":[\"The field Name must be a string or array type with" +
" a minimum length of '15'.\"]}";
var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/SerializableError/CreateEmployee");
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json"));
request.Content = new StringContent(input, Encoding.UTF8, "application/xml");
// Act
var response = await Client.SendAsync(request);
// Assert
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
var actualContent = await response.Content.ReadAsStringAsync();
Assert.Equal(expectedOutput, actualContent);
var modelStateErrors = JsonConvert.DeserializeObject <Dictionary <string, string[]> >(actualContent);
Assert.Equal(2, modelStateErrors.Count);
var errors = Assert.Single(modelStateErrors, kvp => kvp.Key == "Id").Value;
var error = Assert.Single(errors);
Assert.Equal("The field Id must be between 10 and 100.", error);
errors = Assert.Single(modelStateErrors, kvp => kvp.Key == "Name").Value;
error = Assert.Single(errors);
Assert.Equal("The field Name must be a string or array type with a minimum length of '15'.", error);
}
public async Task MaxTopOnProperty(string url, int statusCode)
{
// MaxTop on property override on entity type
string queryUrl =
string.Format(
url,
BaseAddress);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, queryUrl);
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json;odata.metadata=none"));
HttpClient client = new HttpClient();
HttpResponseMessage response = await client.SendAsync(request);
string result = await response.Content.ReadAsStringAsync();
Assert.Equal(statusCode, (int)response.StatusCode);
if (statusCode == (int)HttpStatusCode.BadRequest)
{
Assert.Contains("The limit of '2' for Top query has been exceeded", result);
}
}
public async Task NestedNestedQueryOptionInNextPageLink(string queryOption, string expected)
{
// Arrange
string queryUrl = string.Format(CustomerBaseUrl +
"?$expand=Orders($expand=Details(" + queryOption + "))", BaseAddress);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, queryUrl);
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json;odata.metadata=none"));
HttpClient client = new HttpClient();
// Act
HttpResponseMessage response = await client.SendAsync(request);
// Assert
Assert.NotNull(response);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.NotNull(response.Content);
String result = await response.Content.ReadAsStringAsync();
Assert.Contains(expected, result);
}
public async Task PostEntity_WithDateAndTimeOfDayTimeProperties()
{
// Arrange
const string Payload = "{" +
"\"Id\":99," +
"\"Birthday\":\"2099-01-01\"," +
"\"CreatedTime\":\"14:13:15.1790000\"," +
"\"EndDay\":\"1990-12-22\"}";
string Uri = BaseAddress + "/odata/DateAndTimeOfDayModels";
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, Uri);
request.Content = new StringContent(Payload);
request.Content.Headers.ContentType = MediaTypeWithQualityHeaderValue.Parse("application/json");
// Act
HttpResponseMessage response = await Client.SendAsync(request);
// Assert
Assert.True(response.IsSuccessStatusCode);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
}
public async Task ODataQueryOptionsInRequestBody_ForUnsupportedMediaType()
{
// Arrange
string requestUri = CustomersResourcePath + "/$query";
var contentType = "application/xml";
var queryOptionsPayload = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><QueryOptions><filter>Id le 5</filter></QueryOptions>";
var request = new HttpRequestMessage(HttpMethod.Post, requestUri);
request.Content = new StringContent(queryOptionsPayload);
request.Content.Headers.ContentType = new MediaTypeWithQualityHeaderValue(contentType);
request.Content.Headers.ContentLength = queryOptionsPayload.Length;
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse(ApplicationJsonODataMinimalMetadataStreamingTrue));
HttpClient client = CreateClient();
// Act
var response = await client.SendAsync(request);
// Assert
Assert.False(response.IsSuccessStatusCode);
}
public async Task ActionResultODataPathReturnsBaseWithoutExpansion()
{
// Arrange
string queryUrl = "actionresult/Customers";
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, queryUrl);
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json;odata.metadata=none"));
HttpClient client = CreateClient();
// Act
HttpResponseMessage response = await client.SendAsync(request);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
List <Customer> customers = JToken.Parse(await response.Content.ReadAsStringAsync())["value"].ToObject <List <Customer> >();
Customer customer = Assert.Single(customers);
Assert.Equal("CustId", customer.Id);
Assert.Null(customer.Books);
}
public async Task CanWrite_IEnumerableOf_SerializableErrors()
{
// Arrange
var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/IEnumerable/SerializableErrors");
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/xml-dcs"));
// Act
var response = await Client.SendAsync(request);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var result = await response.Content.ReadAsStringAsync();
XmlAssert.Equal(
"<ArrayOfSerializableErrorWrapper xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\"" +
" xmlns=\"http://schemas.datacontract.org/2004/07/Microsoft.AspNetCore.Mvc.Formatters.Xml\"><SerializableErrorWrapper>" +
"<key1>key1-error</key1><key2>key2-error</key2></SerializableErrorWrapper><SerializableErrorWrapper>" +
"<key3>key1-error</key3><key4>key2-error</key4></SerializableErrorWrapper>" +
"</ArrayOfSerializableErrorWrapper>",
result);
}
public void PutEntity_WithDateTimeProperties()
{
// Arrange
const string Payload = "{" +
"\"BirthdayA\":\"2099-01-01T01:02:03+08:00\"," + // +8 Zone
"\"BirthdayB\":null" +
"}";
const string Uri = "http://localhost/odata/DateTimeModels(3)";
HttpClient client = GetClient(_utcTimeZoneInfo);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Put, Uri);
request.Content = new StringContent(Payload);
request.Content.Headers.ContentType = MediaTypeWithQualityHeaderValue.Parse("application/json");
// Act
HttpResponseMessage response = client.SendAsync(request).Result;
// Assert
Assert.True(response.IsSuccessStatusCode);
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
}
private async Task <HttpResponseMessage> SendApiRequest(FirstTitleRequestBase fTRequest, CancellationToken cancellationToken)
{
if (fTRequest is null)
{
throw new ArgumentNullException(nameof(fTRequest));
}
if (fTRequest.FirstTitleCredential is null)
{
throw new ArgumentException(nameof(fTRequest.FirstTitleCredential));
}
var client_ = _httpClient;
using (var httpRequest = new HttpRequestMessage())
{
if (string.IsNullOrEmpty(fTRequest.Content))
{
httpRequest.Content = null;
}
else
{
var soapRequest = CreateSoapEnvelope(fTRequest.Content);
httpRequest.Content = new StringContent(soapRequest.OuterXml, Encoding.UTF8);
httpRequest.Content.Headers.ContentType = new MediaTypeWithQualityHeaderValue("text/xml");
}
httpRequest.Method = fTRequest.HttpMethod;
httpRequest.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/soap+xml"));
httpRequest.Headers.Authorization = new AuthenticationHeaderValue("Basic", GetBasicAuthValue(fTRequest.FirstTitleCredential));
httpRequest.Headers.Add("SOAPAction", fTRequest.SOAPAction);
httpRequest.RequestUri = ServiceUri;
return(await client_.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(true));
}
}
public async Task TestFiltersWithXmlSerializer()
{
// While this seems ideal for a Theory test case, the IEnumerable<Product> would need to be serialize-able in
// order to generate an Xunit 2.0 test case.
// Some of these test cases may fail rarely because of the random data - the seed for randomization changes every hour though.
var testCases = SpecialCharacterData
.Union(OperatorData)
.Union(StringFunctionData)
.Union(DateAndTimeOfDayData);
//.Union(MixQueries) 1559
//.Union*AdHocTests); 396
foreach (var testCase in testCases)
{
string filter = (string)testCase[0];
IEnumerable <Product> expected = (IEnumerable <Product>)testCase[1];
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, this.BaseAddress + "/api/FilterTests/GetProducts?$filter=" + filter);
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/xml"));
var response = await this.Client.SendAsync(request);
var result = await response.Content.ReadAsObject <IEnumerable <Product> >();
if (expected.Count() == 5 && result.Count() == 8)
{
Assert.True(true);
}
Assert.Equal(expected.Count(), result.Count());
for (int i = 0; i < expected.Count(); i++)
{
Assert.Equal(expected.ElementAt(i).ID, result.ElementAt(i).ID);
Assert.Equal(expected.ElementAt(i).Name, result.ElementAt(i).Name);
Assert.Equal(expected.ElementAt(i).Description, result.ElementAt(i).Description);
}
}
}
public async Task ExpandWithoutAggregation()
{
// Arrange
string queryUrl =
string.Format(
AggregationTestBaseUrl + "?$apply=expand(Orders, filter(Price gt 25))",
BaseAddress);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, queryUrl);
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json;odata.metadata=none"));
HttpClient client = new HttpClient();
// Act
HttpResponseMessage response = client.SendAsync(request).Result;
// Assert
var result = await response.Content.ReadAsObject <JObject>();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var value = (JArray)result["value"];
Assert.Equal(3, value.Count);
Assert.Equal("Customer0", value[0]["Name"].ToObject <string>());
Assert.Equal("Customer1", value[1]["Name"].ToObject <string>());
Assert.Equal("Customer0", value[2]["Name"].ToObject <string>());
var customerZeroOrders = (JArray)value[0]["Orders"];
Assert.Single(customerZeroOrders);
Assert.Equal(75, customerZeroOrders[0]["Price"].ToObject <int>());
var customerOneOrders = (JArray)value[1]["Orders"];
Assert.Equal(2, customerOneOrders.Count);
Assert.Equal(50, customerOneOrders[0]["Price"].ToObject <int>());
Assert.Equal(150, customerOneOrders[1]["Price"].ToObject <int>());
}
public async Task Patch_OpenEntityType()
{
// Arrange
const string Payload = "{" +
"\"CustomerId\":99,\"Name\":\"ChangedName\"," +
"\"[email protected]\":\"#DateTimeOffset\",\"Token\":\"2014-01-01T00:00:00Z\"," +
"\"[email protected]\":\"#Collection(Double)\"," +
"\"DoubleList\":[5.5, 4.4, 3.3]" +
"}";
const string RequestUri = "http://localhost/odata/SimpleOpenCustomers(2)";
var client = GetClient(GetEdmModel(), typeof(SimpleOpenCustomersController));
// Act
HttpRequestMessage request = new HttpRequestMessage(new HttpMethod("PATCH"), RequestUri);
request.Content = new StringContentWithLength(Payload);
request.Content.Headers.ContentType = MediaTypeWithQualityHeaderValue.Parse("application/json");
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json;odata.metadata=full"));
HttpResponseMessage response = await client.SendAsync(request);
// Assert
Assert.True(response.IsSuccessStatusCode);
JObject result = JObject.Parse(await response.Content.ReadAsStringAsync());
Assert.Equal(99, result["CustomerId"]);
Assert.Equal("ChangedName", result["Name"]);
// The type and the value of "Token" are changed.
Assert.Equal("#DateTimeOffset", result["*****@*****.**"]);
// The type and the value of "IntList" are un-changed.
Assert.Equal(new JArray(new[] { 1, 2, 3, 4, 5, 6, 7 }), result["IntList"]);
// New dynamic property "DoubleList" is added.
Assert.Equal(new JArray(new[] { 5.5, 4.4, 3.3 }), result["DoubleList"]);
}
protected T TestGetAction <T>(
string uri,
string format = "application/json",
HttpStatusCode expectedStatus = HttpStatusCode.OK)
{
using (var client = new HttpClient())
{
T result;
var request = new HttpRequestMessage(HttpMethod.Get, BaseUri + uri);
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse(format));
var response = client.SendAsync(request).Result;
var content = response.Content.ReadAsStringAsync().Result;
if (response.StatusCode == HttpStatusCode.Forbidden)
{
throw new UnauthorizedAccessException(content);
}
if (response.StatusCode == HttpStatusCode.BadRequest)
{
throw new InvalidOperationException(content);
}
if (format == "application/json")
{
result = JsonConvert.DeserializeObject <T>(content);
}
else
{
throw new Exception(string.Format("Unexpected format {0}.", format));
}
Assert.AreEqual(expectedStatus, response.StatusCode);
return(result);
}
}
public void OpenComplexType_SimpleSerialization(bool enableNullDynamicProperty)
{
// Arrange
const string RequestUri = "http://localhost/odata/OpenCustomers(2)/Address";
var configuration = new[] { typeof(OpenCustomersController) }.GetHttpConfiguration();
configuration.SetSerializeNullDynamicProperty(enableNullDynamicProperty);
configuration.MapODataServiceRoute("odata", "odata", GetEdmModel());
HttpClient client = new HttpClient(new HttpServer(configuration));
// Act
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, RequestUri);
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json;odata.metadata=full"));
HttpResponseMessage response = client.SendAsync(request).Result;
// Assert
Assert.True(response.IsSuccessStatusCode);
JObject result = JObject.Parse(response.Content.ReadAsStringAsync().Result);
Assert.Equal("http://localhost/odata/$metadata#OpenCustomers(2)/Address", result["@odata.context"]);
Assert.Equal("Street 2", result["Street"]);
Assert.Equal("City 2", result["City"]);
Assert.Equal("300", result["IntProp"]);
Assert.Equal("My Dynamic Country", result["Country"]);
Assert.Equal("2c1f450a-a2a7-4fe1-a25d-4d9332fc0694", result["Token"]);
Assert.Equal("2015-03-02", result["Birthday"]);
if (enableNullDynamicProperty)
{
Assert.NotNull(result["Region"]);
Assert.Equal(JValue.CreateNull(), result["Region"]);
}
else
{
Assert.Null(result["Region"]);
}
}
public async Task RoundTripEntityWorks()
{
// Arrange
int i = 10;
JObject typelessCustomer = new JObject();
typelessCustomer["Id"] = i;
typelessCustomer["Name"] = string.Format("Name {0}", i);
typelessCustomer["Orders"] = CreateOrders(i);
typelessCustomer["Addresses"] = CreateAddresses(i);
typelessCustomer["FavoriteNumbers"] = new JArray(Enumerable.Range(0, i).ToArray());
HttpClient client = CreateClient();
string url = "odata/TypelessCustomers";
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, url);
string payload = typelessCustomer.ToString();
request.Content = new StringContent(payload);
request.Content.Headers.ContentType = MediaTypeWithQualityHeaderValue.Parse("application/json");
request.Content.Headers.ContentLength = payload.Length;
// Act
HttpResponseMessage response = await client.SendAsync(request);
// Assert
Assert.True(response.IsSuccessStatusCode);
// Arrange
HttpRequestMessage getRequest = new HttpRequestMessage(HttpMethod.Get, string.Format("{0}({1})?$expand=Orders", url, i));
getRequest.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json;odata.metadata=none"));
// Act
HttpResponseMessage getResponse = await client.SendAsync(getRequest);
// Assert
Assert.True(getResponse.IsSuccessStatusCode);
Assert.NotNull(getResponse.Content);
JObject returnedObject = await getResponse.Content.ReadAsObject<JObject>();
Assert.Equal(typelessCustomer, returnedObject, JToken.EqualityComparer);
}
private WebCall(Uri uri, Cookies cookies, IEnumerable <KeyValuePair <string, string> > parameters = null, HttpContent content = null, IEnumerable <KeyValuePair <string, string> > headers = null, TimeSpan?timeout = null, bool allowAutoRedirect = true)
{
HttpClientHandler handler = new HttpClientHandler
{
CookieContainer = cookies.Container,
UseCookies = true,
AllowAutoRedirect = allowAutoRedirect
};
_client = new HttpClient(handler)
{
BaseAddress = uri,
DefaultRequestHeaders =
{
Accept = { MediaTypeWithQualityHeaderValue.Parse("*/*") }
},
Timeout = timeout ?? DefaultTimeout
};
if (content != null)
{
_content = content;
}
else if (parameters != null)
{
_content = new FormUrlEncodedContent(parameters);
}
if (headers != null)
{
foreach (var header in headers)
{
_client.DefaultRequestHeaders.TryAddWithoutValidation(header.Key, header.Value);
}
}
_result = new WebCallResult(uri, cookies);
}
public void Post_UnTyped_OpenEntityType()
{
// Arrange
const string Payload = "{" +
"\"@odata.context\":\"http://localhost/odata/$metadata#UntypedSimpleOpenCustomers/$entity\"," +
"\"CustomerId\":6,\"[email protected]\":\"#String\",\"Name\":\"FirstName 6\"," +
"\"Address\":{" +
"\"@odata.type\":\"#NS.Address\",\"Street\":\"Street 6\",\"City\":\"City 6\"" +
"}," +
"\"[email protected]\":\"#Collection(NS.Address)\"," +
"\"Addresses\":[{" +
"\"@odata.type\":\"#NS.Address\",\"Street\":\"Street 7\",\"City\":\"City 7\"" +
"}]," +
"\"[email protected]\":\"#Collection(Double)\"," +
"\"DoubleList\":[5.5, 4.4, 3.3]," +
"\"[email protected]\":\"#NS.Color\"," +
"\"FavoriteColor\":\"Red\"," +
"\"Color\":\"Red\"," +
"\"[email protected]\":\"#Collection(NS.Color)\"," +
"\"FavoriteColors\":[\"0\", \"1\"]" +
"}";
var configuration = new[] { typeof(UntypedSimpleOpenCustomersController) }.GetHttpConfiguration();
configuration.MapODataServiceRoute("odata", "odata", GetUntypedEdmModel());
HttpClient client = new HttpClient(new HttpServer(configuration));
// Act
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, _untypedCustomerRequestRooturl);
request.Content = new StringContent(Payload);
request.Content.Headers.ContentType = MediaTypeWithQualityHeaderValue.Parse("application/json");
HttpResponseMessage response = client.SendAsync(request).Result;
// Assert
Assert.True(response.IsSuccessStatusCode);
}
public void QueryForAnEntryAnIncludeTheRelatedEntriesForASetOfNavigationPropertiesForAnEntry()
{
string queryUrl = string.Format("{0}/selectexpand/SingleResultCustomers(10)?$select=Id,SingleResultOrders,WebStack.QA.Test.OData.QueryComposition.SingleResultPremiumCustomer/Bonuses&$expand=SingleResultOrders,WebStack.QA.Test.OData.QueryComposition.SingleResultPremiumCustomer/Bonuses", BaseAddress);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, queryUrl);
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json;odata=nometadata"));
HttpClient client = new HttpClient();
HttpResponseMessage response;
JObject result;
string content;
response = client.SendAsync(request).Result;
Assert.NotNull(response);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.NotNull(response.Content);
content = response.Content.ReadAsStringAsync().Result;
result = JObject.Parse(content);
Assert.NotNull(result);
Assert.True(result.Properties().Count() == 3);
JArray orders = result["SingleResultOrders"] as JArray;
Assert.Equal((int)result["Id"], orders.Count);
foreach (JObject order in orders)
{
Assert.Equal(3, order.Properties().Count());
}
JArray bonuses = result["Bonuses"] as JArray;
Assert.Equal((int)result["Id"], bonuses.Count);
foreach (JObject bonus in bonuses)
{
Assert.Equal(2, bonus.Properties().Count());
}
}
public async Task ComputeWorks()
{
// Arrange
string queryUrl =
string.Format(
AggregationTestBaseUrl + "?$apply=compute(length(Name) as NameLen)&$filter=Name ne null",
BaseAddress);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, queryUrl);
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json;odata.metadata=none"));
HttpClient client = new HttpClient();
// Act
HttpResponseMessage response = client.SendAsync(request).Result;
// Assert
var result = await response.Content.ReadAsObject <JObject>();
System.Console.WriteLine(result);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var results = result["value"] as JArray;
Assert.Equal(9, results.Count);
foreach (var customer in results)
{
Assert.NotNull(customer["Id"]);
var name = customer["Name"]?.ToString();
if (JValue.CreateNull().Equals(customer["Name"]))
{
Assert.Equal(JValue.CreateNull(), customer["NameLen"]);
}
else
{
Assert.Equal(customer["Name"].ToString().Length.ToString(), customer["NameLen"].ToString());
}
}
}
public async Task <TResponse> Execute <TRequest, TResponse>(HttpMethod method, TRequest request)
{
using (var client = new HttpClient
{
BaseAddress = new Uri(_baseAddress),
})
{
string endpoint;
if (typeof(IParamertisedRequest).IsAssignableFrom(typeof(TRequest)))
{
endpoint = (request as IParamertisedRequest).ToRequestString();
}
else
{
endpoint = (typeof(TRequest)
.GetCustomAttribute(typeof(RequestUrlAttribute)) as RequestUrlAttribute)
.Url;
}
HttpResponseMessage response;
if (method == HttpMethod.Post)
{
var content = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json");
client.DefaultRequestHeaders.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json"));
response = await client.PostAsync(endpoint, content);
}
else
{
client.DefaultRequestHeaders.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json"));
response = await client.GetAsync(endpoint);
}
var responseString = await response.Content.ReadAsStringAsync();
return(Newtonsoft.Json.JsonConvert.DeserializeObject <TResponse>(responseString));
}
}
public void QueryForAnEntryAndIncludeTheRelatedEntriesForAGivenNavigationPropertyPathOnASingleResult()
{
string queryUrl = string.Format("{0}/api/JsonSingleResultCustomer/10?$select=Id,JsonSingleResultOrders&$expand=JsonSingleResultOrders($expand=OrderDetails)", BaseAddress);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, queryUrl);
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json"));
HttpClient client = new HttpClient();
HttpResponseMessage response;
JObject result;
string content;
response = client.SendAsync(request).Result;
Assert.NotNull(response);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.NotNull(response.Content);
content = response.Content.ReadAsStringAsync().Result;
result = JObject.Parse(content);
Assert.NotNull(result);
Assert.True(result.Properties().Count() == 2);
JArray orders = result["JsonSingleResultOrders"] as JArray;
Assert.Equal((int)result["Id"], orders.Count);
foreach (JObject order in (IEnumerable <JToken>)orders)
{
Assert.Equal(3, order.Properties().Count());
JArray orderDetails = order["OrderDetails"] as JArray;
Assert.Equal((int)order["Id"], orderDetails.Count);
foreach (JObject orderDetail in (IEnumerable <JToken>)orderDetails)
{
Assert.Equal(4, orderDetail.Properties().Count());
}
}
}
public string GetNewCommitHash()
{
try
{
using var cts = new CancellationTokenSource(DefaultTimeout);
var requestUri = new Uri(new Uri(Name), $"api/v1/cement/info/head/{branch}");
using var request = new HttpRequestMessage(HttpMethod.Get, requestUri)
{
Headers =
{
Accept = { MediaTypeWithQualityHeaderValue.Parse("application/json") },
UserAgent = { ProductInfoHeaderValue.Parse("Anything") }
}
};
using var response = httpClient.Send(request, cts.Token);
response.EnsureSuccessStatusCode();
// dstarasov: при редиректе свойство RequestUri в запросе изменится на новый адрес
UpdateCementServerIfRequestWasRedirected(requestUri, request.RequestUri);
using var contentStream = response.Content.ReadAsStream(cts.Token);
using var contentStreamReader = new StreamReader(contentStream, Encoding.UTF8);
var content = contentStreamReader.ReadToEnd();
var info = JsonConvert.DeserializeObject <InfoResponseModel>(content);
return(info?.CommitHash);
}
catch (Exception ex)
{
log.LogError(ex, "Failed to look for updates on server");
consoleWriter.WriteWarning("Failed to look for updates on server: " + ex.Message);
return(null);
}
}
public async Task QueryEntitySetWithDollarFormatOverrideAcceptMediaTypeTests(string dollarFormat)
{
// Arrange
string query = $"?$expand=SpecialOrder($select=Detail)&$filter=Id le 5&$orderby=Id desc&$select=Id&$format={dollarFormat}";
string requestUri = $"odata/DollarFormatCustomers{query}";
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, requestUri);
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json"));
HttpClient client = CreateClient();
// Act
HttpResponseMessage response = await client.SendAsync(request);
// Assert
Assert.True(response.IsSuccessStatusCode);
Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType);
if (dollarFormat.ToLowerInvariant().Contains("odata.metadata"))
{
var param = response.Content.Headers.ContentType.Parameters.FirstOrDefault(e => e.Name.Equals("odata.metadata"));
Assert.NotNull(param);
Assert.Contains(param.Value, dollarFormat.ToLowerInvariant());
}
if (dollarFormat.ToLowerInvariant().Contains("odata.streaming"))
{
var param = response.Content.Headers.ContentType.Parameters.FirstOrDefault(e => e.Name.Equals("odata.streaming"));
Assert.NotNull(param);
Assert.Contains(param.Value, dollarFormat.ToLowerInvariant());
}
JObject jObj = await response.Content.ReadAsObject <JObject>();
JArray value = jObj["value"] as JArray;
Assert.Equal(6, value.Count);
}
public void CanDispatch_ActionPayload_With_EdmEnumObject()
{
const string RequestUri = "http://localhost/odata/UntypedSimpleOpenCustomers(1)/NS.AddColor";
const string Payload = @"{
""Color"": ""0""
}";
var configuration = new[] { typeof(UntypedSimpleOpenCustomersController) }.GetHttpConfiguration();
configuration.MapODataServiceRoute("odata", "odata", GetUntypedEdmModel());
HttpClient client = new HttpClient(new HttpServer(configuration));
// Act
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, RequestUri);
request.Content = new StringContent(Payload);
request.Content.Headers.ContentType = MediaTypeWithQualityHeaderValue.Parse("application/json");
HttpResponseMessage response = client.SendAsync(request).Result;
// Assert
Assert.True(response.IsSuccessStatusCode);
}
public async Task FilterWorks(string query)
{
// Arrange
string queryUrl =
string.Format(
AggregationTestBaseUrl + query,
BaseAddress);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, queryUrl);
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json;odata.metadata=none"));
HttpClient client = new HttpClient();
// Act
HttpResponseMessage response = await client.SendAsync(request);
// Assert
var result = await response.Content.ReadAsObject <JObject>();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var results = result["value"] as JArray;
Assert.Single(results);
}
public async Task AggregationOnEntitySetWorks(string method, int expected)
{
// Arrange
string queryUrl = AggregationTestBaseUrl + "?$apply=aggregate(Orders(Price with " + method + " as TotalPrice))";
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, queryUrl);
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json;odata.metadata=none"));
// Act
HttpResponseMessage response = await Client.SendAsync(request);
// Assert
var result = await response.Content.ReadAsObject <JObject>();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var value = result["value"];
var orders = value.First["Orders"];
var TotalPrice = orders.First["TotalPrice"].ToObject <int>();
Assert.Equal(expected, TotalPrice);
}
public async Task PostEntity_WithDateAndTimeOfDayProperties()
{
// Arrange
const string Payload = "{" +
"\"Id\":99," +
"\"Birthday\":\"2099-01-01\"," +
"\"CreatedTime\":\"13:14:15.2190000\"" +
"}";
const string Uri = "http://localhost/odata/DateAndTimeOfDayModels";
HttpClient client = GetClient();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, Uri);
request.Content = new StringContent(Payload);
request.Content.Headers.ContentType = MediaTypeWithQualityHeaderValue.Parse("application/json");
// Act
HttpResponseMessage response = await client.SendAsync(request);
// Assert
Assert.True(response.IsSuccessStatusCode);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Equal(new Uri("http://localhost/odata/DateAndTimeOfDayModels(99)"), response.Headers.Location);
}
public void AggregateMethodWorks(string query, string expectedResult)
{
// Arrange
string queryUrl =
string.Format(
AggregationTestBaseUrl + query,
BaseAddress);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, queryUrl);
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json;odata.metadata=none"));
HttpClient client = new HttpClient();
// Act
HttpResponseMessage response = client.SendAsync(request).Result;
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var result = response.Content.ReadAsAsync <JObject>().Result;
var results = result["value"] as JArray;
Assert.Equal(1, results.Count);
Assert.Equal(expectedResult, results[0]["Result"].ToString());
}
public async Task NoMatchOn_RequestContentType_FallsBackOnTypeBasedMatch_MatchFound(string actionName)
{
// Arrange
var server = TestServer.Create(_provider, _app);
var client = server.CreateClient();
var expectedContentType = MediaTypeHeaderValue.Parse("application/json;charset=utf-8");
var expectedBody = "1234";
var targetUri = "http://localhost/FallbackOnTypeBasedMatch/" + actionName + "/?input=1234";
var content = new StringContent("1234", Encoding.UTF8, "application/custom");
var request = new HttpRequestMessage(HttpMethod.Post, targetUri);
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/custom1"));
request.Content = content;
// Act
var response = await client.SendAsync(request);
// Assert
Assert.Equal(expectedContentType, response.Content.Headers.ContentType);
var body = await response.Content.ReadAsStringAsync();
Assert.Equal(expectedBody, body);
}
/// <summary>
/// WebCall.
/// </summary>
/// <param name="url"> URL. </param>
/// <param name="cookies"> Cookies. </param>
/// <param name="webProxy"> Хост. </param>
/// <param name="allowAutoRedirect"> Разрешить авто редиррект </param>
private WebCall(string url, Cookies cookies, IWebProxy webProxy = null, bool allowAutoRedirect = true)
{
var baseAddress = new Uri(uriString: url);
var handler = new HttpClientHandler
{
CookieContainer = cookies.Container,
UseCookies = true,
Proxy = webProxy,
AllowAutoRedirect = allowAutoRedirect
};
_request = new HttpClient(handler: handler)
{
BaseAddress = baseAddress,
DefaultRequestHeaders =
{
Accept = { MediaTypeWithQualityHeaderValue.Parse(input: "text/html") }
}
};
_result = new WebCallResult(url: url, cookies: cookies);
}
