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