/// <summary>
/// Writes the HTTP response raw.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="response">The response.</param>
public static void WriteHttpResponseRaw <T>(HttpActionResult <T> response)
{
if (DebugCurrent && response != null)
{
_current?.DebugInfo?.WriteHttpResponseRaw(response.Headers, response.Body.SafeToString());
}
}
public void HttpActionResult_InitializesWithResultsStaticMethods()
{
// Arrange & Act
var httpResult = Mock.Of <IResult>();
var result = new HttpActionResult(httpResult);
// Assert
Assert.Equal(httpResult, result.Result);
}
public HttpActionResult <ItemCodeSN_UploadDTO> UploadItemCodeAndSNList([FromBody] string value)
{
string appPath = HttpRuntime.AppDomainAppPath;
HttpActionResult <ItemCodeSN_UploadDTO> result = Newtonsoft.Json.JsonConvert.DeserializeObject <HttpActionResult <ItemCodeSN_UploadDTO> >(value);
string resultMessage = new ItemCodeSNBLL().UploadItemCodeAndSNList(result.Data);
if (string.IsNullOrEmpty(resultMessage))
{
result.Success = true;
}
else
{
result.Success = false;
result.Message = resultMessage;
}
return(result);
}
public async Task HttpActionResult_InvokesInternalHttpResult()
{
// Arrange
var httpContext = new DefaultHttpContext
{
RequestServices = CreateServices().BuildServiceProvider()
};
var context = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());
var httpResult = new Mock <IResult>();
httpResult.Setup(s => s.ExecuteAsync(httpContext))
.Returns(() => Task.CompletedTask)
.Verifiable();
var result = new HttpActionResult(httpResult.Object);
// Act
await result.ExecuteResultAsync(context);
// Assert
httpResult.Verify();
}
/// <summary>
/// Builds the json content result.
/// </summary>
/// <param name="httpRequest">The HTTP request.</param>
/// <param name="rawObject">The raw object.</param>
/// <returns></returns>
public static IHttpActionResult BuildJsonContentResult(HttpRequestMessage httpRequest, object rawObject)
{
var funcName = "BuildJsonContentResult";
IHttpActionResult result = null;
try
{
// Setting for Json serialization
var settings = new JsonSerializerSettings();
settings.Converters.Add(new EFPropertyConverter());
// Serialize .NET object to Json
var json = JsonConvert.SerializeObject(rawObject, settings);
// Call ExecuteAsync to create an HttpResponseMessage, then convert to an HTTP response message.
result = new HttpActionResult(json, httpRequest);
}
catch (Exception ex)
{
Logger.ErrorFormat("{0} - Exception: {1}", funcName, ex.ToString());
}
return(result);
}
public ActionResult <HttpActionResult <PageData <News> > > GetNewsList(int channelId = -1, int pageIndex = 1, int pageSize = 10)
{
var list = newssRepository.GetNewsList(channelId, pageIndex, pageSize);
return(HttpActionResult <PageData <News> > .Successful(list));
}
public async Task <HttpActionResult <List <Channels> > > GetChannels()
{
List <Channels> list = await channelsRepository.GetChannels();
return(HttpActionResult <List <Channels> > .Successful(list));
}
private void SetActionResult()
{
IsValid = false;
ActionResult = new HttpActionResult(HttpStatusCode.BadRequest, new InsertLocationResponse(Message, IsValid));
}
public static void AddTestContextPropertiesFromHttpActionResult <TEntity>(TEntity expectedEntity, HttpActionResult actionResult,
TEntity actualEntityResponse, TestContext testContext, HttpStatusCode httpStatusCode, string expectedException)
{
testContext.Properties.Add("ServiceResponse.Success", $"HttpStatusCode Expected to be:{httpStatusCode}, Actual Value = {actionResult.StatusCode.ToString()}");
var respEntity = actualEntityResponse == null ? "null" : JsonConvert.SerializeObject(actualEntityResponse);
testContext.Properties.Add(Environment.NewLine + "Results", string.Format("{1}Expected Results: {1}{0}{1}{1}Actual Value:{1}{2}",
JsonConvert.SerializeObject(expectedEntity), Environment.NewLine, respEntity));
testContext.Properties.Add(Environment.NewLine + "Exception", string.Format("{0}Expected to be: {1}{0}Actual Value = {2}", Environment.NewLine,
expectedException, actionResult.CommandResult.OperationException));
}
