public override void OnException(HttpActionExecutedContext context)
{
Exception exp;
try
{
var logLevel = GetLogLevel(context.Exception);
_logException(context.Exception, logLevel);
var error = ToError(context.Exception);
var httpResponseMessage = new HttpResponseMessage
{
StatusCode = GetStatusCode(context.Exception),
ReasonPhrase = context.Exception.Message,
RequestMessage = context.Request,
Content = new ObjectContent<Error>(error, new JsonMediaTypeFormatter(), "application/json"),
};
exp = new HttpResponseException(httpResponseMessage);
}
catch (Exception exception)
{
var e = new AggregateException(exception, context.Exception);
_logException(e, LogLevel.SystemError);
throw;
}
throw exp;
}
// GET api/bookdb/5 //"Book id not found",
public BookModel Get(int id)
{
var book = booksDB.Get(id);
if (book == null)
{
var error = ": Book not found with id: " + id.ToString(CultureInfo.InvariantCulture);
var response = new HttpResponseMessage(HttpStatusCode.NotFound);
response.Content = new StringContent(error);
var exc = new HttpResponseException(response);
errorlogContainer.LogMyError(exc);
//throw exc;
}
return book;
}
/// <summary>
/// Executes the HTTP POST method.
/// </summary>
public async Task<HttpResponseMessage> Post(SessionResource resource)
{
// Make sure the resource is valid.
bool resourceIsNull = resource == null;
bool resourceIsInvalid = this.ModelState.IsValid == false;
if (resourceIsNull || resourceIsInvalid)
{
HttpResponseMessage httpResponseMessage = new HttpResponseMessage(HttpStatusCode.BadRequest);
HttpResponseException httpResponseException = new HttpResponseException(httpResponseMessage);
throw httpResponseException;
}
// Open a database connection and begin a database transaction.
using (IDatabaseConnection databaseConnection = await this.databaseConnectionProvider.OpenDatabaseConnection())
using (IDatabaseTransaction databaseTransaction = databaseConnection.BeginDatabaseTransaction())
{
// Invoke the NewSession business operation.
NewSessionBusinessResponse newSessionBusinessResponse = await this.InvokeNewSession(databaseConnection, resource);
// Update the Session resource element.
if (resource.Session != null)
{
resource.Session.SessionCode = newSessionBusinessResponse.Session.SessionCode;
}
// Commit the database transaction.
databaseTransaction.Commit();
// Build an HTTP response message.
HttpResponseMessage httpResponseMessage = this.Request.CreateResponse(HttpStatusCode.Created, resource);
return httpResponseMessage;
}
}
public void Constructor_SetsResponseProperty()
{
var response = new HttpResponseMessage();
var exception = new HttpResponseException(response);
Assert.Same(response, exception.Response);
}
private HttpResponseMessage InternalCreateHttpResponseMessage(HttpResponseException exception, HttpRequestMessage request)
{
if (exception == null)
return null;
OperationOutcome outcome = new OperationOutcome().AddError(exception.Response.ReasonPhrase);
return request.CreateResponse(exception.Response.StatusCode, outcome);
}
public void Constructor_SetsResponsePropertyWithGivenStatusCode()
{
// Arrange and Act
var exception = new HttpResponseException(HttpStatusCode.BadGateway);
// Assert
Assert.Equal(HttpStatusCode.BadGateway, exception.Response.StatusCode);
Assert.Equal("Processing of the HTTP request resulted in an exception. Please see the HTTP response returned by the 'Response' property of this exception for details.", exception.Message);
}
public void Constructor_SetsResponseProperty()
{
// Arrange and Act
var response = new HttpResponseMessage();
var exception = new HttpResponseException(response);
// Assert
Assert.Same(response, exception.Response);
Assert.Equal("Processing of the HTTP request resulted in an exception. Please see the HTTP response returned by the 'Response' property of this exception for details.", exception.Message);
}
public void Constructor_SetsResponseProperty()
{
var response = new HttpResponseMessage();
var exception = new HttpResponseException(response);
Assert.Same(response, exception.Response);
if (Assert.CurrentCultureIsEnglish)
{
Assert.Equal("Processing of the HTTP request resulted in an exception. Please see the HTTP response returned by the 'Response' property of this exception for details.", exception.Message);
}
}
public async Task ReadAsJsonTokenAsync_Throws_IfInvalidJson()
{
// Arrange
Initialize(TestSecret);
_request.Content = new StringContent("I n v a l i d J S O N", Encoding.UTF8, "application/json");
// Act
HttpResponseException ex = await Assert.ThrowsAsync <HttpResponseException>(() => _receiverMock.ReadAsJsonTokenAsync(_request));
// Assert
HttpError error = await ex.Response.Content.ReadAsAsync <HttpError>();
Assert.Equal("The WebHook request contained invalid JSON: 'Error parsing positive infinity value. Path '', line 0, position 0.'.", error.Message);
}
public async Task GetReceiverConfig_Throws_IfInvalidSecret(string secret, int minLength, int maxLength)
{
// Arrange
Initialize(secret);
// Act
HttpResponseException ex = await Assert.ThrowsAsync <HttpResponseException>(() => _receiverMock.GetReceiverConfig(_request, _receiverMock.Name, TestId, minLength, maxLength));
// Assert
string expected = string.Format("Could not find a valid configuration for WebHook receiver 'MockReceiver' and instance '{0}'. The setting must be set to a value between {1} and {2} characters long.", TestId, minLength, maxLength);
HttpError error = await ex.Response.Content.ReadAsAsync <HttpError>();
Assert.Equal(expected, error.Message);
}
public async Task EnsureValidCode_Throws_IfWrongCodeParameter(string id)
{
// Arrange
Initialize(GetConfigValue(id, TestSecret));
_request.RequestUri = new Uri("https://some.no.ssl.host?code=invalid");
// Act
HttpResponseException ex = await Assert.ThrowsAsync <HttpResponseException>(() => _receiverMock.EnsureValidCode(_request, id));
// Assert
HttpError error = await ex.Response.Content.ReadAsAsync <HttpError>();
Assert.Equal("The 'code' query parameter provided in the HTTP request did not match the expected value.", error.Message);
}
public async Task EnsureValidCode_Throws_IfNoCodeParameter(string query)
{
// Arrange
Initialize(TestSecret);
_request.RequestUri = new Uri("https://some.no.ssl.host?" + query);
// Act
HttpResponseException ex = await Assert.ThrowsAsync <HttpResponseException>(() => _receiverMock.EnsureValidCode(_request, TestId));
// Assert
HttpError error = await ex.Response.Content.ReadAsAsync <HttpError>();
Assert.Equal("The WebHook verification request must contain a 'code' query parameter.", error.Message);
}
public async Task EnsureValidCode_Throws_IfNotUsingHttps()
{
// Arrange
Initialize(TestSecret);
_request.RequestUri = new Uri("http://some.no.ssl.host");
// Act
HttpResponseException ex = await Assert.ThrowsAsync <HttpResponseException>(() => _receiverMock.EnsureValidCode(_request, TestId));
// Assert
HttpError error = await ex.Response.Content.ReadAsAsync <HttpError>();
Assert.Equal("The WebHook receiver 'WebHookReceiverMock' requires HTTPS in order to be secure. Please register a WebHook URI of type 'https'.", error.Message);
}
public async Task ReadAsJsonAsync_Throws_IfInvalidJson()
{
// Arrange
Initialize(TestSecret);
_request.Content = new StringContent("I n v a l i d J S O N", Encoding.UTF8, "application/json");
// Act
HttpResponseException ex = await Assert.ThrowsAsync <HttpResponseException>(() => _receiverMock.ReadAsJsonAsync(_request));
// Assert
HttpError error = await ex.Response.Content.ReadAsAsync <HttpError>();
Assert.Equal("The WebHook request must contain an entity body formatted as valid JSON.", error.Message);
}
public void ValidateQuery_Sends_BadRequest_For_Unrecognized_QueryNames()
{
// Arrange
EnableQueryAttribute attribute = new EnableQueryAttribute();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/?$xxx");
var model = new ODataModelBuilder().Add_Customer_EntityType().Add_Customers_EntitySet().GetEdmModel();
var options = new ODataQueryOptions(new ODataQueryContext(model, typeof(System.Web.OData.Builder.TestModels.Customer)), request);
// Act & Assert
HttpResponseException responseException = Assert.Throws <HttpResponseException>(
() => attribute.ValidateQuery(request, options));
Assert.Equal(HttpStatusCode.BadRequest, responseException.Response.StatusCode);
}
public async Task ReadAsXmlAsync_Throws_IfNotXml()
{
// Arrange
Initialize(TestSecret);
_request.Content = new StringContent("Hello World", Encoding.UTF8, "text/plain");
// Act
HttpResponseException ex = await Assert.ThrowsAsync <HttpResponseException>(() => _receiverMock.ReadAsXmlAsync(_request));
// Assert
HttpError error = await ex.Response.Content.ReadAsAsync <HttpError>();
Assert.Equal("The WebHook request must contain an entity body formatted as XML.", error.Message);
}
private static HttpResponseMessage HandleException(
HttpRequestMessage request,
Exception exception
)
{
HttpResponseException httpResponseException = exception as HttpResponseException;
if (httpResponseException != null)
{
return(httpResponseException.Response);
}
return(request.CreateErrorResponse(HttpStatusCode.InternalServerError, exception));
}
internal async Task ProcessRequestAsync(HttpContextBase context)
{
Exception exception = _exceptionInfo.SourceException;
Contract.Assert(exception != null);
HttpRequestMessage request = context.GetOrCreateHttpRequestMessage();
HttpResponseMessage response = null;
CancellationToken cancellationToken = context.Response.GetClientDisconnectedTokenWhenFixed();
HttpResponseException responseException = exception as HttpResponseException;
try
{
if (responseException != null)
{
response = responseException.Response;
Contract.Assert(response != null);
// This method call is hardened and designed not to throw exceptions (since they won't be caught
// and handled further by its callers).
await HttpControllerHandler.CopyResponseAsync(context, request, response, _exceptionLogger,
_exceptionHandler, cancellationToken);
}
else
{
// This method call is hardened and designed not to throw exceptions (since they won't be caught and
// handled further by its callers).
bool handled = await HttpControllerHandler.CopyErrorResponseAsync(
WebHostExceptionCatchBlocks.HttpWebRoute, context, request, null,
_exceptionInfo.SourceException, _exceptionLogger, _exceptionHandler, cancellationToken);
if (!handled)
{
_exceptionInfo.Throw();
}
}
}
finally
{
// The other HttpTaskAsyncHandler is HttpControllerHandler; it has similar cleanup logic.
request.DisposeRequestResources();
request.Dispose();
if (response != null)
{
response.Dispose();
}
}
}
public async Task GetActions_Throws_IfInvalidData(string invalid)
{
Initialize(TestSecret);
CustomReceiverMock mock = new CustomReceiverMock();
JObject data = JObject.Parse(invalid);
// Act
HttpResponseException ex = Assert.Throws <HttpResponseException>(() => mock.GetActions(data, _postRequest));
// Assert
HttpError error = await ex.Response.Content.ReadAsAsync <HttpError>();
Assert.StartsWith("Could not parse WebHook data: ", error.Message);
}
public ActionResult Index()
{
try
{
ViewBag.Ponies = PoniesHelper.GetPonies();
ViewBag.Difficulties = DifficultiesHelper.GetDifficulties();
}
catch (Exception ex)
{
HttpResponseException exception = CreateResponseException(HttpStatusCode.InternalServerError, ex.Message);
throw exception;
}
return(View());
}
public async Task EnsureSecureConnection_ThrowsIfNotLocalAndNotHttps(string address)
{
// Arrange
Initialize(TestSecret);
_request.RequestUri = new Uri(address);
// Act
HttpResponseException ex = Assert.Throws <HttpResponseException>(() => _receiverMock.EnsureSecureConnection(_request));
// Assert
string expected = string.Format("The WebHook receiver 'WebHookReceiverMock' requires HTTPS in order to be secure. Please register a WebHook URI of type 'https'.");
HttpError error = await ex.Response.Content.ReadAsAsync <HttpError>();
Assert.Equal(expected, error.Message);
}
public async Task GetSecretLookupTable_Throws_IfInvalidSecret(string id, string invalid)
{
// Arrange
PusherReceiverMock mock = new PusherReceiverMock();
Initialize(GetConfigValue(id, invalid));
// Act
HttpResponseException ex = await Assert.ThrowsAsync <HttpResponseException>(() => mock.GetSecretLookupTable(id, _postRequest));
// Assert
HttpError error = await ex.Response.Content.ReadAsAsync <HttpError>();
Assert.Equal("The application setting for Pusher must be a comma-separated list of segments of the form '<appKey1>_<appSecret1>; <appKey2>_<appSecret2>'.", error.Message);
}
public async Task Put_ReturnsBadRequest_IfInvalidFilter()
{
// Arrange
await Initialize();
WebHook webHook = CreateWebHook(filterName: "unknown");
// Act
HttpResponseException ex = await Assert.ThrowsAsync <HttpResponseException>(() => _controller.Post(webHook));
// Assert
HttpError error = await ex.Response.Content.ReadAsAsync <HttpError>();
Assert.Equal("The following filters are not valid: 'unknown'. A list of valid filters can be obtained from the path 'http://localhost/'.", error.Message);
}
public async Task CreateBookAsync_AuthorDoesNotExist_ThrowsException()
{
var book = GetProxy();
var authorNotFoundException = new HttpResponseException(HttpStatusCode.NOT_FOUND, "not found");
_authorModelMock
.Setup(x => x.ValidateExistingAuthorAsync(book.AuthorId))
.Throws(authorNotFoundException);
var ex = await Assert.ThrowsExceptionAsync <HttpResponseException>(async() => await _model.CreateBookAsync(book));
Assert.AreEqual(authorNotFoundException.Message, ex.Message);
Assert.AreEqual(authorNotFoundException.StatusCode, ex.StatusCode);
}
public async Task GetBooksByAuthorAsync_BookNotFound_ThrowsException()
{
const int AUTHOR_ID = 1;
var authorNotFoundException = new HttpResponseException(HttpStatusCode.NOT_FOUND, "not found");
_authorModelMock
.Setup(x => x.ValidateExistingAuthorAsync(AUTHOR_ID))
.Throws(authorNotFoundException);
var ex = await Assert.ThrowsExceptionAsync <HttpResponseException>(async() => await _model.GetBooksByAuthorAsync(AUTHOR_ID));
Assert.AreEqual(authorNotFoundException.Message, ex.Message);
Assert.AreEqual(authorNotFoundException.StatusCode, ex.StatusCode);
}
public void WhenGettingAContactAndIsIsMissingThenStatusCodeIsNotFound()
{
var resource = this.GetContactsResourceWithSampleContact();
HttpResponseException exception = null;
try
{
resource.Get(2);
}
catch (HttpResponseException ex)
{
exception = ex;
}
Assert.AreEqual(HttpStatusCode.NotFound, exception.Response.StatusCode);
}
/// <summary>
/// Ensure that all! checks pass
/// </summary>
/// <param name="grants"></param>
/// <param name="preparedException">Out variable to use to throw upstream</param>
/// <returns>True if all pass, false if any one fails</returns>
public bool EnsureAll(List <Grants> grants, out HttpResponseException preparedException)
{
var wrap = Log.Call <bool>();
foreach (var set in PermissionCheckers)
{
if (!set.Value.Ensure(grants, out preparedException))
{
return(wrap(false.ToString(), false));
}
}
preparedException = null;
return(wrap(true.ToString(), true));
}
public async Task ValidateRequest_Throws_IfRequestContentTypeDoesNotHaveBoundary()
{
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler(new HttpServer());
HttpRequestMessage request = new HttpRequestMessage();
request.Content = new StringContent(String.Empty);
request.Content.Headers.ContentType = new MediaTypeHeaderValue("multipart/mixed");
HttpResponseException errorResponse = ExceptionAssert.Throws <HttpResponseException>(
() => batchHandler.ValidateRequest(request));
Assert.Equal(HttpStatusCode.BadRequest, errorResponse.Response.StatusCode);
Assert.Equal("The batch request must have a boundary specification in the \"Content-Type\" header.",
(await errorResponse.Response.Content.ReadAsAsync <HttpError>()).Message);
}
protected override void When()
{
ActionContext = new HttpActionExecutedContext()
{
Exception = new KeyNotFoundException(ExceptionMessage)
};
try
{
SUT.OnException(ActionContext);
}
catch (HttpResponseException exception)
{
NewException = exception;
}
}
/// <summary>
/// Waits for the specified thread to complete or timeout
/// </summary>
/// <param name="t">Thread to wait for timeout</param>
/// <returns>Boolean whether the thread timed out or not</returns>
private static async Task <bool> Wait(Thread t)
{
bool failed = true;
if (t == null)
{
HttpResponseException e = new HttpResponseException(System.Net.HttpStatusCode.InternalServerError);
options.LogThrownException(e);
throw e;
}
failed = await Task.Run(() => TimedOut(t));
return(failed);
}
public async Task ValidateRequest_Throws_IfRequestContentTypeIsNull()
{
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler(new HttpServer());
HttpRequestMessage request = new HttpRequestMessage();
request.Content = new StringContent(String.Empty);
request.Content.Headers.ContentType = null;
HttpResponseException errorResponse = ExceptionAssert.Throws <HttpResponseException>(
() => batchHandler.ValidateRequest(request));
Assert.Equal(HttpStatusCode.BadRequest, errorResponse.Response.StatusCode);
Assert.Equal("The batch request must have a \"Content-Type\" header.",
(await errorResponse.Response.Content.ReadAsAsync <HttpError>()).Message);
}
public async Task ReceiveAsync_Throws_IfPostHasNoSignatureHeader()
{
// Arrange
Initialize(TestSecret);
// Act
HttpResponseException ex = await Assert.ThrowsAsync <HttpResponseException>(() => ReceiverMock.Object.ReceiveAsync(TestId, RequestContext, _postRequest));
// Assert
HttpError error = await ex.Response.Content.ReadAsAsync <HttpError>();
Assert.Equal("Expecting exactly one 'X-Dropbox-Signature' header field in the WebHook request but found 0. Please ensure that the request contains exactly one 'X-Dropbox-Signature' header field.", error.Message);
ReceiverMock.Protected()
.Verify <Task <HttpResponseMessage> >("ExecuteWebHookAsync", Times.Never(), TestId, RequestContext, _postRequest, ItExpr.IsAny <IEnumerable <string> >(), ItExpr.IsAny <object>());
}
public static TheoryData DependencyApiExceptions()
{
string exceptionMessage = GetRandomString();
var responseMessage = new HttpResponseMessage();
var httpResponseException = new HttpResponseException(httpResponseMessage: responseMessage, message: exceptionMessage);
var httpResponseInternalServerErrorException = new HttpResponseInternalServerErrorException(responseMessage: responseMessage, message: exceptionMessage);
return(new TheoryData <Exception>
{
httpResponseException,
httpResponseInternalServerErrorException
});
}
public async Task ValidateRequest_Throws_IfRequestMediaTypeIsWrong()
{
DefaultODataBatchHandler batchHandler = new DefaultODataBatchHandler(new HttpServer());
HttpRequestMessage request = new HttpRequestMessage();
request.Content = new StringContent(String.Empty);
request.Content.Headers.ContentType = new MediaTypeHeaderValue("text/json");
HttpResponseException errorResponse = ExceptionAssert.Throws <HttpResponseException>(
() => batchHandler.ValidateRequest(request));
Assert.Equal(HttpStatusCode.BadRequest, errorResponse.Response.StatusCode);
Assert.Equal("The batch request must have 'multipart/mixed' or 'application/json' as the media type.",
(await errorResponse.Response.Content.ReadAsAsync <HttpError>()).Message);
}
/// <summary>
/// Continue transaction for Message 3/4 sequence
/// </summary>
/// <param name="request">Client Message 3 response/4 request</param>
public static async Task <M4ResponseMessage> Message3(HttpRequestMessage request)
{
log.Debug("Message3(.) started.");
if (request == null)
{
HttpResponseException e = new HttpResponseException(System.Net.HttpStatusCode.InternalServerError);
options.LogThrownException(e);
throw e;
}
M4ResponseMessage m4Response = null;
try
{
ClientTransaction mClient = GetTransaction(request, Constants.msg3Str);
if (mClient == null)
{
HttpResponseException e = new HttpResponseException(System.Net.HttpStatusCode.InternalServerError);
options.LogThrownException(e);
throw e;
}
// kill client wait thread so we don't time out.
mClient.killTimerThread();
// NOTE: There is a potential race-condition where the client is removed from the database during the time that the cilent sends its response
// Can choose to check to re-add the client here in that case
log.Info("\n ***** State: Starting Message 3/4 sequence for client: " + mClient.ID + "\n");
Msg3 msg3 = new Msg3();
m4Response = await msg3.ProcessMessage3(request, mClient.sigmaSequenceCheck);
log.Debug("Message3(.) returning.");
}
catch (HttpResponseException)
{
throw;
}
catch (Exception e)
{
log.Debug("Error processing Message 3/4. " + e.Message);
}
// Return challenge to client
return(m4Response);
}
public async Task <List <EmpleadoDTO> > ImportarArchivoEmpleados(IFormFile file)
{
ArchivoEmpleados archivoDB = await _context.ArchivosEmpleados
.Where(a => a.archivo == file.FileName).FirstOrDefaultAsync();
if (archivoDB != null)
{
throw HttpResponseException.BadRequest("El archivo a importar ya fue procesado o tiene el mismo nombre");
}
List <Empleado> empleados = new List <Empleado>();
bool formatoDeArchivoEsCorrecto = await DeserializadorArchivoEmpleados.FormatoDeDatosDeArchivoEsCorrecto(file.OpenReadStream());
if (formatoDeArchivoEsCorrecto)
{
empleados = await DeserializadorArchivoEmpleados.DeserializarArchivo(file.OpenReadStream(), file.FileName);
empleados = await EliminarEmpleadosExistentesEnDB(empleados);
if (empleados.Count == 0)
{
throw HttpResponseException
.BadRequest("Los empleados del archivo ya estan registrados. Pertenecen a otro de nombre diferente");
}
ArchivoEmpleados archivoDb = await SubirArchivo(file);
if (archivoDb != null)
{
_context.Empleados.AddRange(empleados);
int filasAfectadasDeEmpleados = await _context.SaveChangesAsync();
if (filasAfectadasDeEmpleados == 0)
{
throw HttpResponseException.InternalServer("Error al insertar los Empleados del archivo");
}
}
else
{
throw HttpResponseException.InternalServer("Error al insertar el archivo");
}
}
List <EmpleadoDTO> resul = CrearListaEmpleadosDTO(empleados);
return(resul);
}
public async Task ReceiveAsync_Throws_IfPostIsNotUsingHttps()
{
// Arrange
Initialize(TestSecret);
_postRequest.RequestUri = new Uri("http://some.no.ssl.host");
// Act
HttpResponseException ex = await Assert.ThrowsAsync <HttpResponseException>(() => ReceiverMock.Object.ReceiveAsync(TestId, RequestContext, _postRequest));
// Assert
HttpError error = await ex.Response.Content.ReadAsAsync <HttpError>();
Assert.Equal("The WebHook receiver 'SalesforceSoapWebHookReceiverProxy' requires HTTPS in order to be secure. Please register a WebHook URI of type 'https'.", error.Message);
ReceiverMock.Protected()
.Verify <Task <HttpResponseMessage> >("ExecuteWebHookAsync", Times.Never(), TestId, RequestContext, _postRequest, ItExpr.IsAny <IEnumerable <string> >(), ItExpr.IsAny <object>());
}
public async Task ReceiveAsync_Throws_IfPostIsNotXml()
{
// Arrange
Initialize(TestSecret);
_postRequest.Content = new StringContent("{ }", Encoding.UTF8, "application/json");
// Act
HttpResponseException ex = await Assert.ThrowsAsync <HttpResponseException>(() => ReceiverMock.Object.ReceiveAsync(TestId, RequestContext, _postRequest));
// Assert
HttpError error = await ex.Response.Content.ReadAsAsync <HttpError>();
Assert.Equal("The WebHook request must contain an entity body formatted as XML.", error.Message);
ReceiverMock.Protected()
.Verify <Task <HttpResponseMessage> >("ExecuteWebHookAsync", Times.Never(), TestId, RequestContext, _postRequest, ItExpr.IsAny <IEnumerable <string> >(), ItExpr.IsAny <object>());
}
public int AddIgra([FromBody]string newIgra)
{
try
{
newIgraDTO newIgraDTO = JsonConvert.DeserializeObject<newIgraDTO>(newIgra);
int igra = _panjService.AddIgra(newIgraDTO);
return igra;
}
catch (Exception e)
{
Debug.WriteLine(e);
Exception up = new HttpResponseException(HttpStatusCode.BadRequest);
throw up;
}
}
public static HttpResponseException ResourceNotFoundError(HttpRequestMessage request)
{
HttpResponseException httpException;
HttpResponseMessage response;
ODataError error;
error = new ODataError
{
Message = "Resource Not Found - 404",
ErrorCode = "NotFound"
};
response = request.CreateResponse(HttpStatusCode.NotFound, error);
httpException = new HttpResponseException(response);
return httpException;
}
public void BinarySerialization()
{
byte[] body = new byte[2] { 0, 1 };
HttpHeaders headers = new HttpHeaders();
headers.ContentType = new MediaType("text", "plain");
HttpStatusCode statusCode = HttpStatusCode.Accepted;
string statusDescription = "Accepted description";
HttpResponseException exBefore = new HttpResponseException(
new HttpResponseMessage<byte[]>(body, headers, statusCode, statusDescription));
HttpResponseException exAfter = SerializationTestUtils.BinarySerializeAndDeserialize(exBefore) as HttpResponseException;
Assert.IsNotNull(exAfter);
Assert.AreEqual(body, exAfter.Response.Body, "Invalid response body");
Assert.AreEqual(new MediaType("text", "plain"), exAfter.Response.Headers.ContentType, "Invalid response headers");
Assert.AreEqual(statusCode, exAfter.Response.StatusCode, "Invalid status code");
Assert.AreEqual(statusDescription, exAfter.Response.StatusDescription, "Invalid status description");
}
public void Post(int storyId, string paragraphText) {
Paragraph p = new Paragraph() { NewsItemId = storyId, Text = paragraphText };
int paraNo;
if (db.Paragraphs.Where(e => e.NewsItemId == storyId).Count() == 0)
{
paraNo = 1;
}
else
{
paraNo = db.Paragraphs.Where(e => e.NewsItemId == storyId).OrderByDescending(e => e.ParagraphNumber).First().ParagraphNumber + 1;
}
p.ParagraphNumber = paraNo;
try
{
db.Paragraphs.Add(p);
db.SaveChanges();
}
catch (Exception ex)
{
HttpResponseException httpEx = new HttpResponseException(HttpStatusCode.Conflict);
throw httpEx;
}
}
public void BinarySerialization()
{
Uri requestUri = new Uri("http://www.springframework.net");
HttpMethod requestMethod = HttpMethod.POST;
byte[] body = new byte[2] { 0, 1 };
HttpHeaders headers = new HttpHeaders();
headers.ContentType = new MediaType("text", "plain");
HttpStatusCode statusCode = HttpStatusCode.Accepted;
string statusDescription = "Accepted description";
HttpResponseException exBefore = new HttpResponseException(requestUri, requestMethod,
new HttpResponseMessage<byte[]>(body, headers, statusCode, statusDescription));
HttpResponseException exAfter = SerializationTestUtils.BinarySerializeAndDeserialize(exBefore) as HttpResponseException;
Assert.IsNotNull(exAfter);
Assert.AreEqual(requestUri, exAfter.RequestUri, "Invalid request URI");
Assert.AreEqual(requestMethod, exAfter.RequestMethod, "Invalid request method");
Assert.AreEqual(body, exAfter.Response.Body, "Invalid response body");
Assert.AreEqual(new MediaType("text", "plain"), exAfter.Response.Headers.ContentType, "Invalid response headers");
Assert.AreEqual(statusCode, exAfter.Response.StatusCode, "Invalid status code");
Assert.AreEqual(statusDescription, exAfter.Response.StatusDescription, "Invalid status description");
}
public int AddMec([FromBody]string newMec)
{
try
{
NewMecDTO newMecDTO = JsonConvert.DeserializeObject<NewMecDTO>(newMec);
int addedMecId = _panjService.AddMec(newMecDTO);
return addedMecId;
}
catch (Exception e)
{
Debug.WriteLine(e);
Exception up = new HttpResponseException(HttpStatusCode.BadRequest);
throw up;
}
}
public new virtual void SetUp()
{
base.SetUp();
ApplicationService.Stub(x => x.Create(_applicationWithExistingName)).Throw(new ApplicationNameAlreadyExistsException());
try
{
ApplicationsController.Post(_applicationWithExistingName);
}
catch (HttpResponseException ex)
{
_exception = ex;
}
}
protected override internal void ExecuteRequest(HttpClient httpClient, HttpRequestMessage request)
{
object fullBody = null;
Exception error = null;
HttpResponseMessage response = null;
try
{
if (_tokenSource.IsCancellationRequested)
{
RespondWithResult(fullBody, new Exception(string.Format("{0}: Request {1} has been aborted", this, request)), response);
return;
}
}
catch (AggregateException e)
{
var err = e.InnerException;
Log.E(Tag, "Unhandled Exception", err);
error = err;
RespondWithResult(fullBody, err, response);
return;
}
catch (IOException e)
{
Log.E(Tag, "IO Exception", e);
error = e;
RespondWithResult(fullBody, e, response);
return;
}
catch (Exception e)
{
Log.E(Tag, "ExecuteRequest Exception: ", e);
error = e;
RespondWithResult(fullBody, e, response);
return;
}
try
{
Log.D(Tag + ".ExecuteRequest", "Sending request: {0}", request);
var requestTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_tokenSource.Token);
var responseTask = httpClient.SendAsync(request, requestTokenSource.Token);
if (!responseTask.Wait((Int32)ManagerOptions.Default.RequestTimeout.TotalMilliseconds, requestTokenSource.Token))
{
Log.E(Tag, "Response task timed out: {0}, {1}, {2}", responseTask, TaskScheduler.Current, Description());
throw new HttpResponseException(HttpStatusCode.RequestTimeout);
}
requestTokenSource.Dispose();
response = responseTask.Result;
}
catch (AggregateException e)
{
var err = e.InnerException;
Log.E(Tag, "Unhandled Exception: {0}, {1}", TaskScheduler.Current, Description());
Log.E(Tag, "Unhandled Exception at Line 129 or 130", err);
error = err;
RespondWithResult(fullBody, err, response);
return;
}
catch (IOException e)
{
Log.E(Tag, "IO Exception", e);
error = e;
RespondWithResult(fullBody, e, response);
return;
}
catch (Exception e)
{
Log.E(Tag, "ExecuteRequest Exception: ", e);
error = e;
RespondWithResult(fullBody, e, response);
return;
}
try
{
if (response == null)
{
Log.E(Tag, "Didn't get response for {0}", request);
error = new HttpRequestException();
RespondWithResult(fullBody, error, response);
}
else if (!response.IsSuccessStatusCode)
{
HttpStatusCode status = response.StatusCode;
Log.E(Tag, "Got error status: {0} for {1}. Reason: {2}", status.GetStatusCode(), request, response.ReasonPhrase);
error = new HttpResponseException(status);
RespondWithResult(fullBody, error, response);
}
else
{
Log.D(Tag, "Processing response: {0}", response);
var entity = response.Content;
var contentTypeHeader = entity.Headers.ContentType;
Stream inputStream = null;
if (contentTypeHeader != null && contentTypeHeader.ToString().Contains("multipart/"))
{
Log.V(Tag, "contentTypeHeader = {0}", contentTypeHeader.ToString());
try
{
_topReader = new MultipartReader(contentTypeHeader.ToString(), this);
inputStream = entity.ReadAsStreamAsync().Result;
const int bufLen = 1024;
var buffer = new byte[bufLen];
var numBytesRead = 0;
while ((numBytesRead = inputStream.Read(buffer, 0, bufLen)) > 0)
{
if (numBytesRead != bufLen)
{
var bufferToAppend = new Couchbase.Lite.Util.ArraySegment<byte>(buffer, 0, numBytesRead).ToArray();
_topReader.AppendData(bufferToAppend);
}
else
{
_topReader.AppendData(buffer);
}
}
_topReader.Finished();
RespondWithResult(fullBody, error, response);
}
finally
{
try
{
inputStream.Close();
}
catch (IOException)
{
}
}
}
else
{
Log.V(Tag, "contentTypeHeader is not multipart = {0}", contentTypeHeader.ToString());
if (entity != null)
{
try
{
inputStream = entity.ReadAsStreamAsync().Result;
fullBody = Manager.GetObjectMapper().ReadValue<object>(inputStream);
RespondWithResult(fullBody, error, response);
}
finally
{
try
{
inputStream.Close();
}
catch (IOException)
{
}
}
}
}
}
}
catch (AggregateException e)
{
var err = e.InnerException;
Log.E(Tag, "Unhandled Exception", err);
error = err;
RespondWithResult(fullBody, err, response);
}
catch (IOException e)
{
Log.E(Tag, "IO Exception", e);
error = e;
RespondWithResult(fullBody, e, response);
}
catch (Exception e)
{
Log.E(Tag, "ExecuteRequest Exception: ", e);
error = e;
RespondWithResult(fullBody, e, response);
}
}
public void SetUp()
{
base.SetUp();
CollectionService.Stub(x => x.GetCollectionsByApiKey(ApiKey)).Throw(new ApiKeyNotValidException());
try
{
CollectionController.GetByApiKey(ApiKey);
}
catch (HttpResponseException ex)
{
exception = ex;
}
}
internal void SendAsyncRequest(HttpMethod method, Uri url, Object body, RemoteRequestCompletionBlock completionHandler, CancellationTokenSource requestTokenSource = null)
{
var message = new HttpRequestMessage(method, url);
var mapper = Manager.GetObjectMapper();
message.Headers.Add("Accept", new[] { "multipart/related", "application/json" });
var client = clientFactory.GetHttpClient(false);
var challengeResponseAuth = Authenticator as IChallengeResponseAuthenticator;
if (challengeResponseAuth != null) {
var authHandler = clientFactory.Handler as DefaultAuthHandler;
if (authHandler != null) {
authHandler.Authenticator = challengeResponseAuth;
}
challengeResponseAuth.PrepareWithRequest(message);
}
var authHeader = AuthUtils.GetAuthenticationHeaderValue(Authenticator, message.RequestUri);
if (authHeader != null) {
client.DefaultRequestHeaders.Authorization = authHeader;
}
if (body != null) {
var bytes = mapper.WriteValueAsBytes(body).ToArray();
var byteContent = new ByteArrayContent(bytes);
message.Content = byteContent;
message.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
}
var token = requestTokenSource != null
? requestTokenSource.Token
: CancellationTokenSource.Token;
Log.D(TAG, "Sending async {0} request to: {1}", method, url);
var t = client.SendAsync(message, token) .ContinueWith(response =>
{
try {
lock(_requests) {
_requests.Remove(message);
}
HttpResponseMessage result = null;
Exception error = null;
if (!response.IsFaulted && !response.IsCanceled) {
result = response.Result;
UpdateServerType(result);
} else if(response.IsFaulted) {
error = response.Exception.InnerException;
Log.E(TAG, "Http Message failed to send: {0}", message);
Log.E(TAG, "Http exception", response.Exception.InnerException);
if (message.Content != null) {
Log.E(TAG, "\tFailed content: {0}", message.Content.ReadAsStringAsync().Result);
}
}
if (completionHandler != null) {
object fullBody = null;
try {
if (response.Status != TaskStatus.RanToCompletion) {
Log.D(TAG, "SendAsyncRequest did not run to completion.", response.Exception);
}
if(response.IsCanceled) {
error = new Exception("SendAsyncRequest Task has been canceled.");
} else {
error = error is AggregateException
? response.Exception.Flatten()
: response.Exception;
}
if (error == null) {
if (!result.IsSuccessStatusCode) {
result = response.Result;
error = new HttpResponseException(result.StatusCode);
}
}
if (error == null) {
var content = result.Content;
if (content != null) {
fullBody = mapper.ReadValue<object>(content.ReadAsStreamAsync().Result);
}
error = null;
}
} catch (Exception e) {
error = e;
Log.E(TAG, "SendAsyncRequest has an error occurred.", e);
}
completionHandler(fullBody, error);
}
return result;
} finally {
client.Dispose();
}
}, token, TaskContinuationOptions.None, WorkExecutor.Scheduler);
lock(_requests) {
_requests[message] = t;
}
}
public new virtual void SetUp()
{
base.SetUp();
CollectionService.Stub(x => x.Update(_collectionThatDoesNotExist)).Throw(new ItemNotFoundException());
try
{
CollectionController.Put(_collectionThatDoesNotExist);
}
catch (HttpResponseException ex)
{
_exception = ex;
}
}
protected internal virtual void ExecuteRequest(HttpClient httpClient, HttpRequestMessage req)
{
object fullBody = null;
Exception error = null;
HttpResponseMessage response = null;
try
{
Log.V(Tag, "{0}: RemoteRequest executeRequest() called, url: {1}".Fmt(this, url));
if (request.IsCanceled)
{
Log.V(Tag, "RemoteRequest has already been aborted");
RespondWithResult(fullBody, new Exception(string.Format("{0}: Request {1} has been aborted", this, requestMessage)), response);
return;
}
Log.V(Tag, "{0}: RemoteRequest calling httpClient.execute", this);
response = httpClient.SendAsync(requestMessage, _tokenSource.Token).Result;
Log.V(Tag, "{0}: RemoteRequest called httpClient.execute", this);
var status = response.StatusCode;
if (Misc.IsTransientError(status) && RetryRequest())
{
return;
}
if ((int)status.GetStatusCode() >= 300)
{
Log.E(Tag, "Got error status: {0} for {1}. Reason: {2}", status.GetStatusCode(), requestMessage, response.ReasonPhrase);
error = new HttpResponseException(status);
}
else
{
var temp = response.Content;
if (temp != null)
{
Stream stream = null;
try
{
stream = temp.ReadAsStreamAsync().Result;
fullBody = Manager.GetObjectMapper().ReadValue<object>(stream);
}
finally
{
try
{
stream.Close();
}
catch (IOException)
{
}
}
}
}
}
catch (IOException e)
{
Log.E(Tag, "io exception", e);
error = e;
// Treat all IOExceptions as transient, per:
// http://hc.apache.org/httpclient-3.x/exception-handling.html
Log.V(Tag, "RemoteRequest calling RetryRequest()", this);
if (RetryRequest())
{
return;
}
}
catch (Exception e)
{
Log.E(Tag, "ExecuteRequest() Exception", e);
error = e;
}
Log.V(Tag, "RemoteRequest calling respondWithResult.", error);
RespondWithResult(fullBody, error, response);
}
public void InvokeActionAsync_ForActionResult_PropogatesHttpResponseException()
{
// Arrange
_actionDescriptorMock.Setup(d => d.ReturnType).Returns(typeof(IHttpActionResult));
HttpResponseException expectedException = new HttpResponseException(HttpStatusCode.Ambiguous);
_actionDescriptorMock.Setup(d => d.ExecuteAsync(It.IsAny<HttpControllerContext>(),
It.IsAny<IDictionary<string, object>>(), It.IsAny<CancellationToken>())).Throws(expectedException);
// Act
Task<HttpResponseMessage> task = _actionInvoker.InvokeActionAsync(_actionContext,
CancellationToken.None);
// Assert
task.WaitUntilCompleted();
Assert.Equal<TaskStatus>(TaskStatus.Faulted, task.Status);
Assert.Same(expectedException, task.Exception.InnerException);
}
public new virtual void SetUp()
{
base.SetUp();
ApplicationService.Stub(x => x.GetApplicationsForOrganisation(OrganisationId))
.Throw(new OrganisationIdNotValidException());
try
{
ApplicationsController.GetByOrganisationId(OrganisationId);
}
catch (HttpResponseException ex)
{
_exception = ex;
}
}
public new virtual void SetUp()
{
base.SetUp();
var applicationToUpdate = new Application();
var organisationIdNotValidException = new OrganisationIdNotValidException();
try
{
ApplicationService.Stub(x => x.Update(applicationToUpdate)).Throw(organisationIdNotValidException);
ApplicationsController.Put(applicationToUpdate);
}
catch (HttpResponseException ex)
{
_exception = ex;
}
}
public void SetAktivIgra(int iid)
{
try
{
_panjService.SetAktivIgra(iid);
}
catch (Exception e)
{
Debug.WriteLine(e);
Exception up = new HttpResponseException(HttpStatusCode.BadRequest);
throw up;
}
}
public async Task Post_Handles_ReceiverHttpResponseException()
{
// Arrange
HttpResponseMessage response = new HttpResponseMessage();
HttpResponseException exception = new HttpResponseException(response);
WebHookReceiverMock receiver = new WebHookReceiverMock(exception);
_managerMock.Setup(m => m.GetReceiver(TestReceiver))
.Returns(receiver)
.Verifiable();
// Act
IHttpActionResult result = await _controller.Post(TestReceiver);
HttpResponseMessage actual = ((ResponseMessageResult)result).Response;
// Assert
_managerMock.Verify();
Assert.Same(response, actual);
}
protected override internal Task ExecuteRequest(HttpClient httpClient, HttpRequestMessage request)
{
object fullBody = null;
Exception error = null;
HttpResponseMessage response = null;
if (_tokenSource.IsCancellationRequested)
{
RespondWithResult(fullBody, new Exception(string.Format("{0}: Request {1} has been aborted", this, request)), response);
var tcs = new TaskCompletionSource<bool>();
tcs.SetCanceled();
return tcs.Task;
}
Log.D(Tag + ".ExecuteRequest", "Sending request: {0}", request);
var requestTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_tokenSource.Token);
var retVal = httpClient.SendAsync(request, requestTokenSource.Token);
retVal.ConfigureAwait(false).GetAwaiter().OnCompleted(() => {
requestTokenSource.Dispose();
try {
response = retVal.Result;
} catch(Exception e) {
var err = (e is AggregateException) ? e.InnerException : e;
Log.E(Tag, "Unhandled Exception", err);
error = err;
RespondWithResult(fullBody, err, response);
return;
}
try
{
if (response == null)
{
Log.E(Tag, "Didn't get response for {0}", request);
error = new HttpRequestException();
RespondWithResult(fullBody, error, response);
}
else if (!response.IsSuccessStatusCode)
{
HttpStatusCode status = response.StatusCode;
Log.E(Tag, "Got error status: {0} for {1}. Reason: {2}", status.GetStatusCode(), request, response.ReasonPhrase);
error = new HttpResponseException(status);
RespondWithResult(fullBody, error, response);
}
else
{
Log.D(Tag, "Processing response: {0}", response);
var entity = response.Content;
var contentTypeHeader = entity.Headers.ContentType;
Stream inputStream = null;
if (contentTypeHeader != null && contentTypeHeader.ToString().Contains("multipart/"))
{
Log.V(Tag, "contentTypeHeader = {0}", contentTypeHeader.ToString());
try
{
_topReader = new MultipartReader(contentTypeHeader.ToString(), this);
inputStream = entity.ReadAsStreamAsync().Result;
const int bufLen = 1024;
var buffer = new byte[bufLen];
var numBytesRead = 0;
while ((numBytesRead = inputStream.Read(buffer, 0, bufLen)) > 0)
{
if (numBytesRead != bufLen)
{
var bufferToAppend = new Couchbase.Lite.Util.ArraySegment<byte>(buffer, 0, numBytesRead).ToArray();
_topReader.AppendData(bufferToAppend);
}
else
{
_topReader.AppendData(buffer);
}
}
_topReader.Finished();
RespondWithResult(fullBody, error, response);
}
finally
{
try
{
inputStream.Close();
}
catch (IOException)
{
}
}
}
else
{
Log.V(Tag, "contentTypeHeader is not multipart = {0}", contentTypeHeader.ToString());
if (entity != null)
{
try
{
inputStream = entity.ReadAsStreamAsync().Result;
fullBody = Manager.GetObjectMapper().ReadValue<object>(inputStream);
RespondWithResult(fullBody, error, response);
}
finally
{
try
{
inputStream.Close();
}
catch (IOException)
{
}
}
}
}
}
}
catch (AggregateException e)
{
var err = e.InnerException;
Log.E(Tag, "Unhandled Exception", err);
error = err;
RespondWithResult(fullBody, err, response);
}
catch (IOException e)
{
Log.E(Tag, "IO Exception", e);
error = e;
RespondWithResult(fullBody, e, response);
}
catch (Exception e)
{
Log.E(Tag, "ExecuteRequest Exception: ", e);
error = e;
RespondWithResult(fullBody, e, response);
}
finally {
response.Dispose();
}
});
return retVal;
}
public new virtual void SetUp()
{
base.SetUp();
CollectionService.Stub(x => x.Update(collection)).Throw(new OrganisationIdNotValidException());
try
{
CollectionController.Put(collection);
}
catch (HttpResponseException ex)
{
exception = ex;
}
}
public void SendAsync_Handles_HttpResponseExceptionsThrownInCustomRoutes()
{
// Arrange
HttpResponseException exception = new HttpResponseException(new HttpResponseMessage(HttpStatusCode.HttpVersionNotSupported));
exception.Response.ReasonPhrase = "whatever";
var config = new HttpConfiguration();
config.Routes.Add("throwing route", new ThrowingRoute(exception));
HttpServer server = new HttpServer(config);
var invoker = new HttpMessageInvoker(server);
// Act
var response = invoker.SendAsync(new HttpRequestMessage(), CancellationToken.None).Result;
// Assert
Assert.Equal(exception.Response.StatusCode, response.StatusCode);
Assert.Equal(exception.Response.ReasonPhrase, response.ReasonPhrase);
}
internal void SendAsyncMultipartRequest(HttpMethod method, String relativePath, MultipartContent multiPartEntity, RemoteRequestCompletionBlock completionHandler)
{
Uri url = null;
try {
var urlStr = BuildRelativeURLString(relativePath);
url = new Uri(urlStr);
} catch (UriFormatException e) {
throw new ArgumentException("Invalid URI format.", e);
}
var message = new HttpRequestMessage(method, url);
message.Content = multiPartEntity;
message.Headers.Add("Accept", "*/*");
var client = clientFactory.GetHttpClient(false);
var authHeader = AuthUtils.GetAuthenticationHeaderValue(Authenticator, message.RequestUri);
if (authHeader != null) {
client.DefaultRequestHeaders.Authorization = authHeader;
}
client.SendAsync(message, CancellationTokenSource.Token).ContinueWith(response=>
{
multiPartEntity.Dispose();
if (response.Status != TaskStatus.RanToCompletion)
{
Log.E(TAG, "SendAsyncRequest did not run to completion.", response.Exception);
client.Dispose();
return null;
}
if ((Int32)response.Result.StatusCode > 300) {
LastError = new HttpResponseException(response.Result.StatusCode);
Log.E(TAG, "Server returned HTTP Error", LastError);
client.Dispose();
return null;
}
return response.Result.Content.ReadAsStreamAsync();
}, CancellationTokenSource.Token).ContinueWith(response=>
{
try {
var hasEmptyResult = response.Result == null || response.Result.Result == null || response.Result.Result.Length == 0;
if (response.Status != TaskStatus.RanToCompletion) {
Log.E (TAG, "SendAsyncRequest did not run to completion.", response.Exception);
} else if (hasEmptyResult) {
Log.E (TAG, "Server returned an empty response.", response.Exception ?? LastError);
}
if (completionHandler != null) {
object fullBody = null;
if (!hasEmptyResult) {
var mapper = Manager.GetObjectMapper();
fullBody = mapper.ReadValue<Object> (response.Result.Result);
}
completionHandler (fullBody, response.Exception);
}
} finally {
client.Dispose();
}
}, CancellationTokenSource.Token);
}
private bool EsBadRequest(HttpResponseException ex, String causa, String userNameEsperado)
{
return ex.Response.StatusCode.Equals(HttpStatusCode.BadRequest) &&
ex.Response.ReasonPhrase.Equals(causa) &&
ex.Response.Content.As<ObjectContent<ErrorRegistracion>>().Value.As<ErrorRegistracion>().NombreUsuario.Equals(userNameEsperado);
}
