private async Task <HttpResponseMessage> PerformSendingRequest(CustomHttpMethod method, string url, object objectToPost)
{
switch (method)
{
case CustomHttpMethod.PostJson:
var jsonFormatter = new JsonMediaTypeFormatter
{
SerializerSettings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
}
};
return(await Client.PostAsync(url, objectToPost, jsonFormatter));
case CustomHttpMethod.PostForm:
var actualData = (IEnumerable <KeyValuePair <string, string> >)objectToPost ?? EmptyFormData;
return(await Client.PostAsync(url, new FormUrlEncodedContent(actualData)));
case CustomHttpMethod.Get:
return(await Client.GetAsync(url));
case CustomHttpMethod.Put:
return(await Client.PutAsJsonAsync(url, objectToPost));
case CustomHttpMethod.Delete:
return(await Client.DeleteAsync(url));
default:
throw new ArgumentOutOfRangeException(nameof(method), method, null);
}
}
private async Task <HttpResponseMessage> PerformSendingRequest(CustomHttpMethod method, string url, object objectToPost)
{
var settings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
var json = JsonConvert.SerializeObject(objectToPost, settings);
HttpContent content = new StringContent(json, Encoding.UTF8, "application/json");
switch (method)
{
case CustomHttpMethod.PostJson:
return(await Client.PostAsync(url, content));
case CustomHttpMethod.PostForm:
var actualData = (IEnumerable <KeyValuePair <string, string> >)objectToPost ?? EmptyFormData;
return(await Client.PostAsync(url, new FormUrlEncodedContent(actualData)));
case CustomHttpMethod.Get:
return(await Client.GetAsync(url));
case CustomHttpMethod.Put:
return(await Client.PutAsync(url, content));
case CustomHttpMethod.Delete:
return(await Client.DeleteAsync(url));
default:
throw new ArgumentOutOfRangeException(nameof(method), method, null);
}
}
private static void AddApiRequestRoute(ICollection <object[]> routingData, string expectedControllerName,
string expectedActionName, CustomHttpMethod httpMethod, string baseUrl, object objectToPost = null)
{
var expectedControllerMethodName = $"VirtoCommerce.Storefront.Controllers.Api.{expectedControllerName}Controller.{expectedActionName} " +
"(VirtoCommerce.Storefront)";
routingData.Add(new[] { httpMethod, baseUrl, expectedControllerMethodName, objectToPost });
}
/// <summary>
/// Method to make HTTP requests to send objects as serialized string. This method accepts parameters to configure the HTTP method, URL, Entity object, ContentType and headers.
/// </summary>
/// <typeparam name="T">Type of the custom error entity used to deserialize an error response from a HttpResponseMessage's content.</typeparam>
/// <param name="method">HTTP methods accepted: POST,PUT,PATCH. <see cref="CustomHttpMethod"/></param>
/// <param name="url">The URL the request is sent to.</param>
/// <param name="entity">Entity to serilize in JSON format.</param>
/// <param name="contentType">Request's ContentType..</param>
/// <param name="headers">Request's header parameters.</param>
/// <returns>Returns the string content of the HttpResponseMessage.</returns>
public async Task <string> SendObjectAsync <T>(CustomHttpMethod method, string url, Object entity, string contentType = "application/json", Dictionary <string, string> headers = null)
{
try
{
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(contentType));
var jsonString = JsonConvert.SerializeObject(entity);
var httpContent = new StringContent(jsonString, Encoding.UTF8, contentType);
if (headers != null)
{
foreach (KeyValuePair <string, string> keyValuePair in headers)
{
client.DefaultRequestHeaders.Remove(keyValuePair.Key);
client.DefaultRequestHeaders.Add(keyValuePair.Key, keyValuePair.Value);
}
}
HttpResponseMessage response = null;
switch (method)
{
case CustomHttpMethod.Post:
response = await this.client.PostAsync(url, httpContent);
break;
case CustomHttpMethod.Put:
response = await this.client.PutAsync(url, httpContent);
break;
case CustomHttpMethod.Patch:
var request = new HttpRequestMessage(new HttpMethod("PATCH"), url)
{
Content = httpContent
};
response = await this.client.SendAsync(request);
break;
}
var responseText = await response.Content.ReadAsStringAsync();
this.ShouldThrowException <T>(response.StatusCode, responseText);
return(responseText);
}
catch (HttpRequestException)
{
return(null);
}
finally
{
client.DefaultRequestHeaders.Accept.Clear();
}
}
private async Task PerformTestingRouting(CustomHttpMethod method, string url, string expectedControllerMethodName, object objectToPost)
{
var response = await PerformSendingRequest(method, url, objectToPost);
response.EnsureSuccessStatusCode();
var responseContent = await response.Content.ReadAsStringAsync();
var routingData = JsonConvert.DeserializeObject <RoutingDataResult>(responseContent);
Assert.NotNull(routingData);
Assert.Equal(expectedControllerMethodName, routingData.ControllerMethodName);
}
public async Task TestRouting(CustomHttpMethod method, string url, string expectedControllerMethodName, object objectToPost)
{
// Act & Assert
var urlVariations = EnumerateUrlVariations(url);
// Note: Theoretically, each of these URL variations could be a separate test case, and this test
// could be a bit simplier. But splitting variations to different test cases also slows test run a lot.
// So, to speed up tests execution, we reuse the same test server for all URL variations of request.
foreach (var urlVariation in urlVariations)
{
await PerformTestingRouting(method, urlVariation, expectedControllerMethodName, objectToPost);
}
}
/// <summary>
/// Method to make HTTP requests. This method accepts parameters to configure the HTTP method, URL, ContentType, querystring parameters and headers.
/// </summary>
/// <typeparam name="T">Type of the custom error entity used to deserialize an error response from a HttpResponseMessage's content.</typeparam>
/// <param name="method">HTTP methods accepted: GET,POST,PUT,DELETE. <see cref="CustomHttpMethod"/></param>
/// <param name="url">The URL the request is sent to.</param>
/// <param name="contentType">Request's ContentType.</param>
/// <param name="parameters">Request's parameters.</param>
/// <param name="headers">Request's header parameters.</param>
/// <returns>Returns the string content of the HttpResponseMessage.</returns>
public async Task <string> SendAsync <T>(CustomHttpMethod method, string url, string contentType = "application/x-www-form-urlencoded", List <KeyValuePair <string, string> > parameters = null, Dictionary <string, string> headers = null)
{
try
{
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(contentType));
string data = string.Empty;
if (parameters != null)
{
List <string> pairs = new List <string>();
parameters.ForEach(parameter => pairs.Add($"{parameter.Key}={WebUtility.UrlEncode(parameter.Value)}"));
data = string.Join("&", pairs);
}
var httpContent = new StringContent(data, Encoding.UTF8, contentType);
if (headers != null)
{
foreach (KeyValuePair <string, string> keyValuePair in headers)
{
client.DefaultRequestHeaders.Remove(keyValuePair.Key);
client.DefaultRequestHeaders.Add(keyValuePair.Key, keyValuePair.Value);
}
}
HttpResponseMessage response = null;
switch (method)
{
case CustomHttpMethod.Get:
response = await this.client.GetAsync(url);
break;
case CustomHttpMethod.Post:
response = await this.client.PostAsync(url, httpContent);
break;
case CustomHttpMethod.Put:
response = await this.client.PutAsync(url, httpContent);
break;
case CustomHttpMethod.Delete:
response = await this.client.DeleteAsync(url);
break;
}
var responseText = await response.Content.ReadAsStringAsync();
this.ShouldThrowException <T>(response.StatusCode, responseText);
return(responseText);
}
catch (HttpRequestException)
{
return(null);
}
finally
{
client.DefaultRequestHeaders.Accept.Clear();
}
}