public ResponseEntity HandleInternalServerErrorException(InternalServerErrorException exception)
{
var toReturn = ExceptionData.MakeExceptionData("An internal server error has occured", exception);
var entity = new ResponseEntity(toReturn, Headers, exception.Status);
return(entity);
}
public void Throw_ShouldReturnMessage()
{
var message = "The Server has encountered an error.";
var error = new InternalServerErrorException();
Assert.Equal(message, error.Message);
}
public void ContructorTest()
{
Assert.True(typeof(InternalServerErrorException).IsSubclassOf(typeof(MtgExceptionBase)));
InternalServerErrorException exception = new InternalServerErrorException("testing");
Assert.Equal("MTG Api Error, testing", exception.Message);
}
public async Task <TResponse> Handle(
TRequest request,
CancellationToken cancellationToken,
RequestHandlerDelegate <TResponse> next)
{
_logger.LogInformation("Request: {@Request}." + UserIdMessage(), request);
_timer.Start();
var response = default(TResponse);
Exception responseException = null;
try
{
response = await next();
}
catch (AppException exception)
{
_logger.LogError("Request {Status}: {Message}." + UserIdMessage(), exception.Status, exception.Message);
responseException = exception;
}
catch (DomainException exception)
{
_logger.LogError("Domain Exception: {Message}." + UserIdMessage(), exception.Message);
responseException = exception;
}
catch (DbUpdateConcurrencyException)
{
_logger.LogError("Request Concurrency Exception: {@Request}." + UserIdMessage(), request);
responseException =
new ConflictException("Data have been modified since entities were loaded.");
}
catch (Exception exception)
{
_logger.LogCritical(exception, "Unexpected Server Exception." + UserIdMessage());
responseException = new InternalServerErrorException();
}
_timer.Stop();
if (_timer.ElapsedMilliseconds > 2000)
{
_logger.LogWarning(
"Request Performance Issue: {@Request} ({ElapsedMilliseconds} milliseconds)." + UserIdMessage(),
request,
_timer.ElapsedMilliseconds);
}
if (responseException != null)
{
throw responseException;
}
return(response);
}
public override AmazonServiceException UnmarshallException(JsonUnmarshallerContext context, Exception innerException, HttpStatusCode statusCode)
{
ErrorResponse errorResponse = JsonErrorResponseUnmarshaller.GetInstance().Unmarshall(context);
if (errorResponse.Code != null && errorResponse.Code.Equals("InternalServerErrorException"))
{
InternalServerErrorException ex = new InternalServerErrorException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode);
return(ex);
}
return(new AmazonElasticMapReduceException(errorResponse.Message, innerException, errorResponse.Type, errorResponse.Code, errorResponse.RequestId, statusCode));
}
public void CreatesAStringWithBodyAndNoHeaders()
{
string body = "Body.";
var endpoint = new Uri("https://www.some.url");
var method = new HttpMethod("GET");
var request = new Request("", endpoint, new HttpHeader[0], method);
var response = new Response(body, false, "plain/text", new List <KeyValuePair <string, IEnumerable <string> > >(), HttpStatusCode.InternalServerError);
var exception = new InternalServerErrorException(request, response, "Custom message.");
var expectedSerialization = $"InternalServerErrorException (Custom message.) for request {method} {endpoint} with response {{\"status\":\"500 InternalServerError\",\"headers\":{{}},\"body\":\"{body}\"}}";
var serialized = exception.ToString();
serialized.Should().Be(expectedSerialization);
}
public void CreatesAStringWithBodyAndNoHeaders()
{
string body = "Body.";
var endpoint = new Uri("https://www.some.url");
var method = new HttpMethod("GET");
var request = new Request("", endpoint, new HttpHeader[0], method);
var response = new Response(body, false, "application/json", new List<KeyValuePair<string, IEnumerable<string>>>(), HttpStatusCode.InternalServerError);
var exception = new InternalServerErrorException(request, response, "Custom message.");
var expectedSerialization = $"ApiException for request {method} {endpoint}: Response: (Status: [500 InternalServerError]) (Headers: []) (Body: {body}) (Message: Custom message.)";
var serialized = exception.ToString();
serialized.Should().Be(expectedSerialization);
}
/// <summary>
/// Monta InternalServerErrorException e imprimir um log de erro de acordo com os parâmetros.
/// </summary>
/// <param name="exception">Exceção lançada.</param>
/// <param name="logger">Objeto para impressão da mensagem de log.</param>
/// <param name="code">Código do erro à ser mostrado na mensagem.</param>
/// <param name="message">Mensagem complementar à ser mostrada no log e na exceção.</param>
/// <param name="args">Uma lista de objetos que contém um ou mais objetos para formatar com a mensagem.</param>
/// <returns>Exceção do tipo <see cref="InternalServerErrorException"/> com a mensagem gerada.</returns>
public static InternalServerErrorException ToInternalServerException(
this Exception exception,
ILogger logger,
string code,
string message,
params object[] args)
{
var newEx = new InternalServerErrorException(message, code, exception);
// ReSharper disable once TemplateIsNotCompileTimeConstantProblem
logger.LogError(exception, newEx.ToString());
return(newEx);
}
public void CreatesAStringWithBodyAndWithHeaders()
{
string body = "Body of a response with headers.";
var endpoint = new Uri("https://www.some.url/endpoint");
var method = new HttpMethod("GET");
var request = new Request("", endpoint, new HttpHeader[0], method);
var headers = new[] { new KeyValuePair <string, IEnumerable <string> >("abc", new[] { "a", "b", "c" }) };
var response = new Response(body, false, "application/json", headers, HttpStatusCode.InternalServerError);
var exception = new InternalServerErrorException(request, response, "Custom message.");
var expectedSerialization = $"InternalServerErrorException for request {method} {endpoint}: Response: (Status: [500 InternalServerError]) (Headers: ['abc': ['a', 'b', 'c']]) (Body: {body}) (Message: Custom message.)";
var serialized = exception.ToString();
serialized.Should().Be(expectedSerialization);
}
public void TheErrorMessageMatchesTheMessageFromTheReasonException(NonNull <string> message)
{
var entity = CreateDirtyEntity();
var response = Substitute.For <IResponse>();
response.RawData.Returns(message.Get);
var exception = new InternalServerErrorException(Substitute.For <IRequest>(), response);
var reason = new BadRequestException(request, response);
var state = CreateState(repository);
prepareBatchUpdate(entity);
var transition = state.Start((reason, entity)).SingleAsync().Wait();
var unsyncableEntity = ((Transition <TModel>)transition).Parameter;
unsyncableEntity.LastSyncErrorMessage.Should().Be(message.Get);
}
/// <summary>
/// Throw request exception asynchronous.
/// </summary>
/// <exception cref="RequestException">
/// Thrown when a Request error condition occurs.
/// </exception>
/// <returns>
/// A <see cref="Task" /> representing the operation.
/// </returns>
private static async Task ThrowRequestExceptionAsync(HttpResponseMessage response)
{
string content = await response.Content.ReadAsStringAsync()
.ConfigureAwait(continueOnCapturedContext: false);
Error error = ParseError(response.StatusCode, content);
RequestException requestException;
switch (response.StatusCode)
{
case HttpStatusCode.BadRequest:
requestException = new BadRequestException(error.Message, error.Code, error.Reason);
break;
case HttpStatusCode.Forbidden:
requestException = new UnauthorizedAccessException(error.Message, error.Code, error.Reason);
break;
case HttpStatusCode.InternalServerError:
requestException = new InternalServerErrorException(error.Message, error.Code, error.Reason);
break;
case HttpStatusCode.NotFound:
requestException = new ResourceNotFoundException(error.Message, error.Code, error.Reason);
break;
case HttpStatusCode.Unauthorized:
requestException = new AuthenticationFailureException(error.Message, error.Code, error.Reason);
break;
default:
requestException = new RequestException(error.Message, error.Code, error.Reason);
break;
}
throw requestException;
}
private Task HandleException(HttpContext context, Exception error)
{
context.Response.ContentType = "application/json";
ErrorDetails errorDetails;
try
{
errorDetails = ((CustomException)error).errorDetails;
}
catch (System.Exception)
{
var errorMessage = "Something went wrong, please try again later";
if (_env.IsDevelopment())
{
errorMessage = error.Message;
}
var internalServerError = new InternalServerErrorException(HttpStatusCode.InternalServerError, errorMessage);
errorDetails = internalServerError.errorDetails;
}
context.Response.StatusCode = (int)errorDetails.Status;
return(context.Response.WriteAsync(errorDetails.ToString()));
}
/// <summary>
/// The handle.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
/// <param name="cancellationToken">
/// The cancellation token.
/// </param>
public void HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
{
var logger = (ILogger)context.Request.GetDependencyScope().GetService(typeof(ILogger));
logger.Exception(context.Exception);
InternalServerErrorException internalServerErrorException = (InternalServerErrorException)context.Request.GetDependencyScope();
internalServerErrorException.GetException(BaseErrorCodes.UnhandledException, context.Exception);
var messageToReturn = internalServerErrorException.Content;
// var messageToReturn = "Something went wrong on the server";
////For the time being we are reading the app setting variable directly from appsettings since environment library is not stable.
// TODO:must have to read the appsetting through Environment Library.
var enableErrorDetails = !string.IsNullOrEmpty(ConfigurationManager.AppSettings["EnableErrorDetails"]) &&
Convert.ToBoolean(ConfigurationManager.AppSettings["EnableErrorDetails"]);
//if (EnvironmentInfo.IsDevelopmentMachine || enableErrorDetails)
//{
// var sb = new StringBuilder();
// sb.AppendLine();
// sb.AppendLine();
// sb.AppendLine("------------------- Development Environment ----------------------");
// sb.AppendLine(context.Exception.GetType().FullName);
// sb.AppendLine(this.GetMessageToReturn(context.Exception, Environment.NewLine));
// sb.AppendLine(context.Exception.StackTrace);
// messageToReturn = sb.ToString();
//}
var statusCode = HttpStatusCode.InternalServerError;
if (context.Exception is NotImplementedException)
{
statusCode = HttpStatusCode.NotImplemented;
}
/*
* else if (context.Exception is AuthorizationException)
* {
* statusCode = HttpStatusCode.Forbidden;
* }
* else if (context.Exception is InvalidInputException)
* {
* var exception = (InvalidInputException)context.Exception;
*
* ObjectContent<List<string>> content = new ObjectContent<List<string>>(exception.Errors, new JsonMediaTypeFormatter());
* var response = new HttpResponseMessage(HttpStatusCode.BadRequest)
* {
* Content = content,
* ReasonPhrase = "Invalid Input",
* RequestMessage = context.ExceptionContext.Request
* };
* context.Result = new ErrorMessageResult(response);
* return;
* }
* else if (context.Exception is ExternalRequestException)
* {
* var exception = (ExternalRequestException)context.Exception;
*
* /*
* statusCode = exception.ExternalResult.StatusCode;
* var response = new HttpResponseMessage(statusCode)
* {
* Content = new StringContent(exception.Content),
* ReasonPhrase = "Bad Request",
* RequestMessage = context.ExceptionContext.Request
* };
*
*
* context.Result = new ErrorMessageResult(exception.ExternalResult);
* return;
* }
*/
// return the errors back to the caller
// context.Response = useHttpError
// ? context.Request.CreateErrorResponse(statusCode, messageToReturn)
// : context.Request.CreateResponse(statusCode);
var resp = new HttpResponseMessage(statusCode)
{
Content = messageToReturn,
ReasonPhrase = context.Exception.GetType().FullName,
RequestMessage = context.ExceptionContext.Request
};
context.Result = new ErrorMessageResult(resp);
}
