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); }