/// <summary>
/// Returns a new <see cref="ObjectResult"/> for the given <paramref name="exception"/>.
/// </summary>
/// <param name="exception">The <see cref="Exception"/> to use for error information.</param>
/// <param name="includeErrorDetail">
/// <see langword="true"/> to include the <see cref="Exception"/> information in the error;
/// <see langword="false"/> otherwise.
/// </param>
/// <returns>
/// An <see cref="ObjectResult"/> that when executed will produce a response containing a generic error
/// message and, if <paramref name="includeErrorDetail"/> is <see langword="true"/>, details about the
/// <paramref name="exception"/>. The response will by default have the Bad Request (400) status code.
/// </returns>
/// <remarks>
/// <paramref name="exception"/> is ignored when <paramref name="includeErrorDetail"/> is
/// <see langword="false"/>, but useful when debugging even in that case.
/// </remarks>
public static ObjectResult CreateErrorResult(Exception exception, bool includeErrorDetail)
{
if (exception == null)
{
throw new ArgumentNullException(nameof(exception));
}
var error = new SerializableError
{
{ WebHookErrorKeys.MessageKey, Resources.ResultUtilities_GenericError },
};
if (includeErrorDetail)
{
error.Add(WebHookErrorKeys.ExceptionMessageKey, exception.Message);
error.Add(WebHookErrorKeys.ExceptionTypeKey, exception.GetType().FullName);
error.Add(WebHookErrorKeys.StackTraceKey, exception.StackTrace);
if (exception.InnerException != null)
{
error.Add(
WebHookErrorKeys.InnerExceptionKey,
CreateErrorResult(exception.InnerException, includeErrorDetail));
}
}
return(new BadRequestObjectResult(error));
}
public IEnumerable<SerializableError> SerializableErrors()
{
List<SerializableError> errors = new List<SerializableError>();
var error1 = new SerializableError();
error1.Add("key1", "key1-error");
error1.Add("key2", "key2-error");
var error2 = new SerializableError();
error2.Add("key3", "key1-error");
error2.Add("key4", "key2-error");
errors.Add(error1);
errors.Add(error2);
return errors;
}
public void CanEnumerateOn_WrappableElementTypes()
{
// Arrange
var error1 = new SerializableError();
error1.Add("key1", "key1-error");
var error2 = new SerializableError();
error2.Add("key1", "key1-error");
var errors = new[] { error1, error2 };
var delegatingEnumerable = new DelegatingEnumerable <SerializableErrorWrapper, SerializableError>(
errors,
new SerializableErrorWrapperProvider());
// Act and Assert
Assert.Equal(errors.Length, delegatingEnumerable.Count());
for (var i = 0; i < errors.Length; i++)
{
var errorWrapper = delegatingEnumerable.ElementAt(i);
Assert.IsType <SerializableErrorWrapper>(errorWrapper);
Assert.NotNull(errorWrapper);
Assert.Same(errors[i], errorWrapper.SerializableError);
}
}
public IEnumerable <SerializableError> SerializableErrors()
{
List <SerializableError> errors = new List <SerializableError>();
var error1 = new SerializableError();
error1.Add("key1", "key1-error");
error1.Add("key2", "key2-error");
var error2 = new SerializableError();
error2.Add("key3", "key1-error");
error2.Add("key4", "key2-error");
errors.Add(error1);
errors.Add(error2);
return(errors);
}
public SerializableError Build()
{
SerializableError serializableError = new SerializableError();
foreach (KeyValuePair <string, object> error in _errors)
{
serializableError.Add(error.Key, error.Value);
}
return(serializableError);
}
public static SerializableError CreateSerializableErrorFromModelState(this ODataController controller)
{
// https://source.dot.net/#Microsoft.AspNetCore.Mvc.Core/SerializableError.cs,19bc9a1c61ce7ae0
var serializableError = new SerializableError();
foreach (var keyModelStatePair in controller.ModelState)
{
var key = keyModelStatePair.Key;
var errors = keyModelStatePair.Value.Errors;
if (errors != null && errors.Count > 0)
{
var errorMessages = errors.Select(error =>
{
return(string.IsNullOrEmpty(error.ErrorMessage) ? "The input was not valid." : error.ErrorMessage);
}).ToArray();
serializableError.Add(key, errorMessages);
foreach (var error in errors)
{
if (error.Exception != null)
{
// Add more error details.
// e.g.
// ```
// One or more errors occurred. (
// One or more errors occurred. (
// A null value was found for the property named 'UnitPrice', which has the expected type 'Edm.Decimal[Nullable=False]'.
// The expected type 'Edm.Decimal[Nullable=False]' does not allow null values.
// )
// )
// ```
serializableError.Add("MessageDetail", error.Exception.Message);
}
}
}
}
return(serializableError);
}
public override void OnException(ExceptionContext context)
{
var badRequest = context.Exception as BadRequestException;
if (badRequest != null)
{
var error = new SerializableError();
error.Add(badRequest.Key ?? "Reason", new string[] { context.Exception.Message });
context.Result = new ObjectResult(error)
{
StatusCode = 400
};
}
}
/// <summary>
/// Create an error response.
/// </summary>
/// <param name="message">The message of the error.</param>
/// <param name="exception">The error exception if any.</param>
/// <returns>A SerializableError.</returns>
/// <remarks>This function is recursive.</remarks>
public static SerializableError CreateErrorResponse(string message, Exception exception = null)
{
// The key values mimic the behavior of HttpError in AspNet. It's a fine format
// and many of the test cases expect it.
SerializableError error = new SerializableError();
if (!String.IsNullOrEmpty(message))
{
error.Add(SerializableErrorKeys.MessageKey, message);
}
if (exception != null)
{
error.Add(SerializableErrorKeys.ExceptionMessageKey, exception.Message);
error.Add(SerializableErrorKeys.ExceptionTypeKey, exception.GetType().FullName);
error.Add(SerializableErrorKeys.StackTraceKey, exception.StackTrace);
if (exception.InnerException != null)
{
error.Add(SerializableErrorKeys.InnerExceptionKey, CreateErrorResponse(String.Empty, exception.InnerException));
}
}
return(error);
}
public void WrappedSerializableErrorInstance_ReturnedFromProperty()
{
// Arrange
var serializableError = new SerializableError();
serializableError.Add("key1", "key1-error");
// Act
var wrapper = new SerializableErrorWrapper(serializableError);
// Assert
Assert.NotNull(wrapper.SerializableError);
Assert.Same(serializableError, wrapper.SerializableError);
Assert.Equal(1, wrapper.SerializableError.Count);
Assert.True(wrapper.SerializableError.ContainsKey("key1"));
Assert.Equal("key1-error", wrapper.SerializableError["key1"]);
}
public void WrappedSerializableErrorInstance_ReturnedFromProperty()
{
// Arrange
var serializableError = new SerializableError();
serializableError.Add("key1", "key1-error");
// Act
var wrapper = new SerializableErrorWrapper(serializableError);
// Assert
Assert.NotNull(wrapper.SerializableError);
Assert.Same(serializableError, wrapper.SerializableError);
Assert.Single(wrapper.SerializableError);
Assert.True(wrapper.SerializableError.ContainsKey("key1"));
Assert.Equal("key1-error", wrapper.SerializableError["key1"]);
}
public void CanEnumerateOn_WrappableElementTypes()
{
// Arrange
var error1 = new SerializableError();
error1.Add("key1", "key1-error");
var error2 = new SerializableError();
error2.Add("key1", "key1-error");
var errors = new[] { error1, error2 };
var delegatingEnumerable = new DelegatingEnumerable<SerializableErrorWrapper, SerializableError>(
errors,
new SerializableErrorWrapperProvider());
// Act and Assert
Assert.Equal(errors.Length, delegatingEnumerable.Count());
for (var i = 0; i < errors.Length; i++)
{
var errorWrapper = delegatingEnumerable.ElementAt(i);
Assert.IsType<SerializableErrorWrapper>(errorWrapper);
Assert.NotNull(errorWrapper);
Assert.Same(errors[i], errorWrapper.SerializableError);
}
}