public void LookupIsCaseInsensitive() { // Arrange var modelState = new ModelStateDictionary(); modelState.AddModelError("key1", "x"); // Act var serializableError = new SerializableError(modelState); // Assert var arr = Assert.IsType<string[]>(serializableError["KEY1"]); Assert.Equal("x", arr[0]); }
public void WriteXml_WritesValidXml() { // Arrange var modelState = new ModelStateDictionary(); modelState.AddModelError("key1", "Test Error 1"); modelState.AddModelError("key1", "Test Error 2"); modelState.AddModelError("key2", "Test Error 3"); var serializableError = new SerializableError(modelState); var outputStream = new MemoryStream(); // Act using (var xmlWriter = XmlWriter.Create(outputStream)) { var dataContractSerializer = new DataContractSerializer(typeof(SerializableErrorWrapper)); dataContractSerializer.WriteObject(xmlWriter, new SerializableErrorWrapper(serializableError)); } outputStream.Position = 0; var res = new StreamReader(outputStream, Encoding.UTF8).ReadToEnd(); // Assert var expectedContent = TestPlatformHelper.IsMono ? "<?xml version=\"1.0\" encoding=\"utf-8\"?><Error xmlns:i=\"" + "http://www.w3.org/2001/XMLSchema-instance\"><key1>Test Error 1 Test Error 2</key1>" + "<key2>Test Error 3</key2></Error>" : "<?xml version=\"1.0\" encoding=\"utf-8\"?>" + "<Error><key1>Test Error 1 Test Error 2</key1><key2>Test Error 3</key2></Error>"; Assert.Equal(expectedContent, res); }
/// <summary> /// Initializes a new instance of the <see cref="SerializableErrorWrapper"/> class. /// </summary> /// <param name="error">The <see cref="SerializableError"/> object that needs to be wrapped.</param> public SerializableErrorWrapper(SerializableError error) { if (error == null) { throw new ArgumentNullException(nameof(error)); } SerializableError = error; }
public void DoesNotThrowOn_EmptyCollections_WrappableElementTypes() { // Arrange var errors = new SerializableError[] { }; var delegatingEnumerable = new DelegatingEnumerable<SerializableErrorWrapper, SerializableError>( errors, new SerializableErrorWrapperProvider()); // Act and Assert Assert.Empty(delegatingEnumerable); }
public void ConvertsModelState_To_Dictionary_AddsDefaultValuesWhenErrorsAreAbsent() { // Arrange var modelState = new ModelStateDictionary(); modelState.AddModelError("key1", ""); // Act var serializableError = new SerializableError(modelState); // Assert var arr = Assert.IsType<string[]>(serializableError["key1"]); Assert.Equal("The input was not valid.", arr[0]); }
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 Wraps_SerializableErrorInstance() { // Arrange var wrapperProvider = new SerializableErrorWrapperProvider(); var serializableError = new SerializableError(); // Act var wrapped = wrapperProvider.Wrap(serializableError); // Assert Assert.NotNull(wrapped); var errorWrapper = wrapped as SerializableErrorWrapper; Assert.NotNull(errorWrapper); Assert.Same(serializableError, errorWrapper.SerializableError); }
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 DoesNotAddEntries_IfNoErrorsArePresent() { // Arrange var modelState = new ModelStateDictionary(); modelState.Add( "key1", new ModelState() { Value = new ValueProviderResult("foo", "foo", CultureInfo.InvariantCulture) }); modelState.Add( "key2", new ModelState() { Value = new ValueProviderResult("bar", "bar", CultureInfo.InvariantCulture) }); // Act var serializableError = new SerializableError(modelState); // Assert Assert.Equal(0, serializableError.Count); }
public void ConvertsModelState_To_Dictionary() { // Arrange var modelState = new ModelStateDictionary(); modelState.AddModelError("key1", "Test Error 1"); modelState.AddModelError("key1", "Test Error 2"); modelState.AddModelError("key2", "Test Error 3"); // Act var serializableError = new SerializableError(modelState); // Assert var arr = Assert.IsType<string[]>(serializableError["key1"]); Assert.Equal("Test Error 1", arr[0]); Assert.Equal("Test Error 2", arr[1]); Assert.Equal("Test Error 3", (serializableError["key2"] as string[])[0]); }
public void DoesNotAddEntries_IfNoErrorsArePresent() { // Arrange var modelState = new ModelStateDictionary(); modelState.Add( "key1", new ModelStateEntry()); modelState.Add( "key2", new ModelStateEntry()); // Act var serializableError = new SerializableError(modelState); // Assert Assert.Equal(0, serializableError.Count); }
public void UpdateUserWithModelErrorReturnsValidationErrorMessage() { var userDTO = new UserDTO(); // Arrange var serviceMoq = new Mock <IUserService>(); UserController userController = new UserController(serviceMoq.Object, AutomapperSingleton.Mapper); userController.ModelState.AddModelError("Name", "Required"); // Act BadRequestObjectResult result = (BadRequestObjectResult)userController.UpdateUser(userDTO); // Assert Assert.IsType <BadRequestObjectResult>(result); SerializableError errorMessages = (SerializableError)result.Value; Assert.Equal("Required", ((string[])errorMessages["Name"])[0]); }
public void WrappedSerializableErrorInstance_ReturnedFromProperty() { // Arrange var serializableError = new SerializableError { { "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 UpdateOrder_Fail_InvalidModelState() { // Setup Fixtures. const string key = "key"; const string errorMessage = TestValues.ExceptionMessage; // Execute SUT. this._sut.ModelState.AddModelError(key, errorMessage); IActionResult result = this._sut.UpdateOrder(null, TestValues.OrderUpdateDto); // Verify Results. BadRequestObjectResult badRequestResult = Assert.IsType <BadRequestObjectResult>(result); SerializableError error = Assert.IsType <SerializableError>(badRequestResult.Value); Assert.Single(error); string[] messages = Assert.IsType <string[]>(error[key]); Assert.Single(messages); Assert.Equal(errorMessage, messages[0]); }
public void ConvertsModelState_To_Dictionary() { // Arrange var modelState = new ModelStateDictionary(); modelState.AddModelError("key1", "Test Error 1"); modelState.AddModelError("key1", "Test Error 2"); modelState.AddModelError("key2", "Test Error 3"); // Act var serializableError = new SerializableError(modelState); // Assert var arr = Assert.IsType <string[]>(serializableError["key1"]); Assert.Equal("Test Error 1", arr[0]); Assert.Equal("Test Error 2", arr[1]); Assert.Equal("Test Error 3", (serializableError["key2"] as string[])[0]); }
public static ODataError CreateODataError(this SerializableError serializableError, bool isDevelopment) { var convertedError = SerializableErrorExtensions.CreateODataError(serializableError); var error = new ODataError(); if (isDevelopment) { error = convertedError; } else { error.Message = DefaultODataErrorMessage; error.Details = new[] { new ODataErrorDetail { Message = convertedError.Message } }; } return(error); }
public async Task GetPayment_ReturnsBadRequestObjectResult_WhenInvalidModelStateReturned() { // Arrange Guid id = Guid.NewGuid(); PaymentRespModel paymentRespModel = null; ModelStateDictionary modelStateDictionary = new ModelStateDictionary(); modelStateDictionary.AddModelError("UnitTest", "Error"); mockPaymentManager.Setup(s => s.GetAsync(It.IsAny <Guid>(), It.IsAny <ModelStateDictionary>())) .Returns(Task.FromResult <(PaymentRespModel, ModelStateDictionary)>((paymentRespModel, modelStateDictionary))) .Verifiable(); // Act ActionResult actionResult = await paymentController.Get(id) as ActionResult; // Assert Assert.IsNotNull(actionResult); Assert.IsInstanceOf <BadRequestObjectResult>(actionResult); BadRequestObjectResult badRequestObjectResult = actionResult as BadRequestObjectResult; Assert.IsNotNull(badRequestObjectResult); Assert.AreEqual(StatusCodes.Status400BadRequest, badRequestObjectResult.StatusCode); Assert.IsNotNull(badRequestObjectResult.Value); Assert.IsInstanceOf <SerializableError>(badRequestObjectResult.Value); SerializableError serializableError = badRequestObjectResult.Value as SerializableError; Assert.IsNotNull(serializableError); Assert.AreEqual(1, serializableError.Keys.Count()); Assert.IsTrue(serializableError.ContainsKey("UnitTest")); mockPaymentManager.Verify(v => v.GetAsync(It.IsAny <Guid>(), It.IsAny <ModelStateDictionary>())); }
public void CreateODataError_Creates_ODataError_UsingModelStateDictionary() { // Arrange & Act & Assert ModelStateDictionary modelState = new ModelStateDictionary(); modelState.AddModelError("key1", "Test Error 1"); modelState.AddModelError("key1", "Test Error 2"); modelState.AddModelError("key3", "Test Error 3"); SerializableError serializableError = new SerializableError(modelState); // Act ODataError error = SerializableErrorExtensions.CreateODataError(serializableError); // Assert Assert.NotNull(error); Assert.Equal("key1:\r\nTest Error 1\r\nTest Error 2\r\n\r\nkey3:\r\nTest Error 3", error.Message); Assert.Null(error.ErrorCode); Assert.Null(error.InnerError); Assert.Equal(3, error.Details.Count); }
// This method gets called by the runtime. Use this method to add services to the container. // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940 public void ConfigureServices(IServiceCollection services) { // Applicatioin Services services.AddScoped <IAccountRepository, AccountRepository>(); services.AddControllers(); // Model validation error response services.Configure <ApiBehaviorOptions>(options => { options.InvalidModelStateResponseFactory = context => { var errors = new SerializableError(context.ModelState); var result = new UnprocessableEntityObjectResult(new { errors }); return(result); }; }); // Register Swagger generator. services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo { Title = "Thought.API", Version = "v1" }); }); }
public async Task PostCategory_ReturnsBadRequestResult400_WhenModelStateIsInvalid() { //ARRANGE: Alle methodes opgeroepen in de controller, moeten gemocked worden . //1. Aanmaak nieuwe DTO onnodig -> model voert validatie uit //2. Mocking van controller en alle controller methodes () mockCategoryRepo.Setup(repo => repo.Create(It.IsAny <Category>())) //.Returns(Task.FromResult(mapper.ConvertTo_Entity(newTask, ref newTaskEntity))) //cutomised mapper .Returns(Task.FromResult(mapper.Map <CategoryEditCreateDTO, Category>(new CategoryEditCreateDTO()))); var APIcontroller = new CategoriesController(mockCategoryRepo.Object, mockRepo.Object, mapper, null, memoryCache, null); //3. controleer of mockRepo opgeroepen werd; mockCategoryRepo.Verify(); //ACT : controller oproepen met model error (must) APIcontroller.ModelState.AddModelError("CategoryName", "Required"); var actionResult = await APIcontroller.PostCategory(new CategoryEditCreateDTO()); var badReqObjResult = (BadRequestObjectResult)actionResult.Result; //BAdRequest(ModelState) kan geserializeerd worden. SerializableError badReqError = badReqObjResult.Value as SerializableError; //var JsonString = JsonConvert.SerializeObject(badReqError); //ASSERT Assert.IsInstanceOfType(badReqObjResult, typeof(BadRequestObjectResult)); Assert.IsInstanceOfType(((BadRequestObjectResult)badReqObjResult).Value, typeof(SerializableError)); Assert.AreEqual(400, badReqObjResult.StatusCode); //omzetten naar string[] om index te kunnen gebruiken Assert.AreEqual(((string[])badReqError["CategoryName"])[0], "Required"); //alternatief: for lus foreach (var error in badReqError) { if (error.Key == "CategoryName") { Assert.AreEqual(((string[])error.Value)[0], "Required"); } } }
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 static ODataError CreateODataError(this SerializableError serializableError, bool isDevelopment) { // ReSharper disable once InvokeAsExtensionMethod var convertedError = SerializableErrorExtensions.CreateODataError(serializableError); var error = new ODataError(); if (isDevelopment) { error = convertedError; } else { // Sanitise the exposed data when in release mode. // We do not want to give the public access to stack traces, etc! error.Message = DefaultODataErrorMessage; error.Details = new[] { new ODataErrorDetail { Message = convertedError.Message } }; } return(error); }
public void CreateODataError_Creates_AdvancedODataError() { // Arrange & Act & Assert ModelStateDictionary modelState = new ModelStateDictionary(); modelState.AddModelError("key1", "Test Error 1"); SerializableError serializableError = new SerializableError(modelState); serializableError["ErrorCode"] = "Error Code 1"; serializableError["Message"] = "Error Message 1"; serializableError["ExceptionMessage"] = "Error ExceptionMessage 1"; // Act ODataError error = SerializableErrorExtensions.CreateODataError(serializableError); // Assert Assert.NotNull(error); Assert.Equal("Error Message 1", error.Message); Assert.Equal("Error Code 1", error.ErrorCode); Assert.Equal("Error ExceptionMessage 1", error.InnerError.Message); Assert.Single(error.Details); }
public void OnResultExecuting(ResultExecutingContext context) { if (context.Result is BadRequestObjectResult) { BadRequestObjectResult res = (BadRequestObjectResult)context.Result; SerializableError obj = res.Value as SerializableError; StringBuilder sb = new StringBuilder(); foreach (var item in obj) { var vals = item.Value as string[]; if (vals != null) { sb.AppendLine(vals[0]); } } context.Result = new JsonResult(new { Code = -3, Message = sb.ToString() }) { StatusCode = 200 }; return; } }
public async Task CanValidateModelFields_UpdateVehicle_ModelAndFeaturesDoNotExistInDb() { SaveVehicleResource vehicleResource = new SaveVehicleResource { Contact = new ContacResource { Name = "Person", Email = "*****@*****.**", Phone = "2222222" }, LastUpdate = DateTime.Now, IsRegistered = true, ModelId = 1, Features = new List <int> { 3, 5, 7, 9 } }; _vehiclesRepository.Setup(db => db.GetWithDependenciesAsync(123)).ReturnsAsync(_vehicleWithId123); _vehiclesRepository.Setup(db => db.IsModelExists(1)).ReturnsAsync(false); _vehiclesRepository.Setup(db => db.IsFeatureExists(It.IsInRange(5, 7, Range.Inclusive))).ReturnsAsync(true); _vehiclesRepository.Setup(db => db.IsFeatureExists(3)).ReturnsAsync(false); _vehiclesRepository.Setup(db => db.IsFeatureExists(9)).ReturnsAsync(false); IActionResult actual = await _controller.UpdateVehicleAsync(123, vehicleResource); _vehiclesRepository.Verify(db => db.GetWithDependenciesAsync(123), Times.Once); _vehiclesRepository.Verify(db => db.IsModelExists(1), Times.Once); _vehiclesRepository.Verify(db => db.IsFeatureExists(It.IsAny <int>()), Times.Exactly(4)); _unitOfWork.Verify(u => u.CompeleteAsync(), Times.Never); Assert.IsInstanceOf <BadRequestObjectResult>(actual); BadRequestObjectResult result = actual as BadRequestObjectResult; SerializableError errorList = result?.Value as SerializableError; Assert.IsNotNull(errorList); Assert.AreEqual(2, errorList.Count); CollectionAssert.AreEqual(new[] { "Cannot find model with Id = 1" }, errorList["ModelId"] as string[]); CollectionAssert.AreEqual(new[] { "Cannot find feature with Id = 3", "Cannot find feature with Id = 9" }, errorList["Features"] as string[]); }
public override void OnResultExecuting(ResultExecutingContext context) { if (context.Result is ErrorableActionResult actionResult) { if (!actionResult.Result.Success) { var localizer = context.HttpContext.RequestServices.GetRequiredService <IStringLocalizer <ErrorableResultFilterAttribute> >(); var error = new SerializableError { { Errors, actionResult.Result.Messages.Select(m => localizer[m].Value) } }; context.Result = new BadRequestObjectResult(error); LogFailureResult(actionResult.Result, context .HttpContext .RequestServices .GetRequiredService <ILogger <ErrorableResultFilterAttribute> >()); return; } if (context.HttpContext.Request.Method == "DELETE") { context.Result = new NoContentResult(); return; } if (actionResult.Result is IResult <object> objectResult) { context.Result = new OkObjectResult(objectResult.Data); } else { context.Result = new OkResult(); } } }
public void WriteXml_WritesValidXml() { // Arrange var modelState = new ModelStateDictionary(); modelState.AddModelError("key1", "Test Error 1"); modelState.AddModelError("key1", "Test Error 2"); modelState.AddModelError("key2", "Test Error 3"); var serializableError = new SerializableError(modelState); var outputStream = new MemoryStream(); // Act using (var xmlWriter = XmlWriter.Create(outputStream)) { var dataContractSerializer = new DataContractSerializer(typeof(SerializableErrorWrapper)); dataContractSerializer.WriteObject(xmlWriter, new SerializableErrorWrapper(serializableError)); } outputStream.Position = 0; var res = new StreamReader(outputStream, Encoding.UTF8).ReadToEnd(); // Assert Assert.Equal("<?xml version=\"1.0\" encoding=\"utf-8\"?>" + "<Error><key1>Test Error 1 Test Error 2</key1><key2>Test Error 3</key2></Error>", res); }
/// <summary> /// Converts the <paramref name="serializableError"/> to an <see cref="ODataError"/>. /// </summary> /// <param name="serializableError">The <see cref="SerializableError"/> instance to convert.</param> /// <returns>The converted <see cref="ODataError"/></returns> public static ODataError CreateODataError(this SerializableError serializableError) { if (serializableError == null) { throw Error.ArgumentNull("serializableError"); } string message = serializableError.GetPropertyValue <string>(SerializableErrorKeys.MessageKey); string details = ConvertModelStateErrors(serializableError); return(new ODataError { Message = string.IsNullOrEmpty(message) ? details : message, ErrorCode = serializableError.GetPropertyValue <string>(SerializableErrorKeys.ErrorCodeKey), InnerError = ToODataInnerError(serializableError), Details = serializableError .Select(kvp => new ODataErrorDetail() { Message = kvp.Key + ":" + kvp.Value, }) .AsCollection(), }); }
private static ODataInnerError ToODataInnerError(SerializableError serializableError) { string innerErrorMessage = serializableError.GetPropertyValue <string>(SerializableErrorKeys.ExceptionMessageKey); if (innerErrorMessage == null) { string messageDetail = serializableError.GetPropertyValue <string>(SerializableErrorKeys.MessageDetailKey); if (messageDetail == null) { SerializableError modelStateError = serializableError.GetPropertyValue <SerializableError>(SerializableErrorKeys.ModelStateKey); return((modelStateError == null) ? null : new ODataInnerError { Message = ConvertModelStateErrors(modelStateError) }); } else { return(new ODataInnerError() { Message = messageDetail }); } } else { ODataInnerError innerError = new ODataInnerError(); innerError.Message = innerErrorMessage; innerError.TypeName = serializableError.GetPropertyValue <string>(SerializableErrorKeys.ExceptionTypeKey); innerError.StackTrace = serializableError.GetPropertyValue <string>(SerializableErrorKeys.StackTraceKey); SerializableError innerExceptionError = serializableError.GetPropertyValue <SerializableError>(SerializableErrorKeys.InnerExceptionKey); if (innerExceptionError != null) { innerError.InnerError = ToODataInnerError(innerExceptionError); } return(innerError); } }
public void CreateODataError_Creates_BasicODataError_WithoutModelStateDictionary() { // Arrange & Act & Assert ModelStateDictionary modelState = new ModelStateDictionary(); modelState.AddModelError("key3", "Test Error 3"); SerializableError innerSerializableError = new SerializableError(modelState); SerializableError serializableError = new SerializableError(); serializableError["key1"] = "Test Error 1"; serializableError["key2"] = "Test Error 2"; serializableError["ModelState"] = innerSerializableError; // Act ODataError error = SerializableErrorExtensions.CreateODataError(serializableError); // Assert Assert.NotNull(error); Assert.Equal("key1:\r\nTest Error 1\r\n\r\nkey2:\r\nTest Error 2", error.Message); Assert.Null(error.ErrorCode); Assert.Equal("key3:\r\nTest Error 3", error.InnerError.Message); Assert.Equal(2, error.Details.Count); }
/// <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 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 async Task CreateReturnsBadRequestIfRequestFailsValidation() { string invalidProperty = NewRandomString(); string errorMessage = NewRandomString(); CreateProfilePatternRequest request = NewCreateRequest(_ => _.WithPattern(NewProfilePattern())); ValidationResult expectedValidationResult = NewValidationResult(_ => _.WithFailures(NewValidationFailure(vf => vf.WithPropertyName(invalidProperty) .WithErrorMessage(errorMessage)))); GivenTheValidationResultForTheCreateRequest(request, expectedValidationResult); SerializableError serializableError = (await WhenTheProfilePatternIsCreated(request) as BadRequestObjectResult)? .Value as SerializableError; serializableError?[invalidProperty] .Should() .BeEquivalentTo(new[] { errorMessage }); AndNoProfilePatternsWereSaved(); AndTheCacheWasNotInvalidated(); }
/// <summary> /// Applies the specified model. /// </summary> /// <param name="model">The model.</param> /// <param name="context">The context.</param> public void Apply(Schema model, SchemaFilterContext context) { if (model == null) { throw new ArgumentNullException(nameof(model)); } if (context == null) { throw new ArgumentNullException(nameof(context)); } if (context.SystemType == typeof(ModelStateDictionary)) { var modelState = new ModelStateDictionary(); modelState.AddModelError("Property1", "Error message 1"); modelState.AddModelError("Property1", "Error message 2"); modelState.AddModelError("Property2", "Error message 3"); var serializableError = new SerializableError(modelState); model.Default = serializableError; model.Example = serializableError; } }
public static void ContainsKeyAndErrorMessage(this SerializableError error, string key, string errorMessage) { error.Should().NotBeNull(); error.ContainsKey(key).Should().BeTrue(); ((string[])error[key])[0].Should().Be(errorMessage); }
private static IDictionary <string, string[]> GetValidationErrors(SerializableError error) { return(error.Where(x => x.Value is string[]).ToDictionary(x => x.Key, x => (string[])x.Value)); }
/// <summary> /// Initializes a new instance of the <see cref="SerializableErrorWrapper"/> class. /// </summary> /// <param name="error">The <see cref="SerializableError"/> object that needs to be wrapped.</param> public SerializableErrorWrapper([NotNull] SerializableError error) { SerializableError = error; }
// Note: XmlSerializer requires to have default constructor public SerializableErrorWrapper() { SerializableError = new SerializableError(); }
/// <summary> /// Create an ODataError from an HttpError. /// </summary> /// <param name="error">The error to use.</param> /// <returns>an ODataError.</returns> internal static ODataError CreateODataError(object error) { SerializableError serializableError = error as SerializableError; return(serializableError.CreateODataError()); }
public SerializableError LogErrors([FromBody] SerializableError serializableError) { return(serializableError); }
private async Task <WebApiResponse <TOutput> > GetHttpResponse <TOutput, TInput>(HttpVerb verb, string endPoint, TInput input, bool throwException = false) { using (var client = new HttpClient()) { client.BaseAddress = new Uri(_baseAddress); client.DefaultRequestHeaders.Accept.Clear(); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); StringContent content = null; // HTTP POST HttpResponseMessage response = null; switch (verb) { case HttpVerb.Get: response = await client.GetAsync(endPoint); break; case HttpVerb.Post: content = new StringContent(JsonSerializer.Serialize(input), Encoding.UTF8, "application/json"); response = await client.PostAsync(endPoint, content); break; case HttpVerb.Put: content = new StringContent(JsonSerializer.Serialize(input), Encoding.UTF8, "application/json"); response = await client.PutAsync(endPoint, content); break; case HttpVerb.Delete: response = await client.DeleteAsync(endPoint); break; default: break; } //response.EnsureSuccessStatusCode(); string data = await response.Content.ReadAsStringAsync(); var result = new WebApiResponse <TOutput>(); result.IsSucceded = response.IsSuccessStatusCode; result.StatusCode = response.StatusCode; try { var serializeOptions = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase, PropertyNameCaseInsensitive = true }; result.Response = JsonSerializer.Deserialize <TOutput>(data, serializeOptions); } catch (Exception ex) { // ignored } if (!response.IsSuccessStatusCode) { SerializableError err = null; try { err = JsonSerializer.Deserialize <SerializableError>(data); } catch (Exception) { // ignored } if (err?.Any() == true) { var message = err.First().Value.ToString(); if (throwException) { var ex = new Exception(message); foreach (var item in err) { if (!ex.Data.Contains(item.Key)) { ex.Data.Add(item.Key, item.Value); } } throw ex; } else { result.Message = message; result.Errors = new List <ErrorItem>(); foreach (var item in err) { if (result.Errors.All(x => x.Key != item.Key)) { result.Errors.Add(new ErrorItem { Key = item.Key, Value = Convert.ToString(item.Value) }); } } } } } return(result); } }
/// <summary> /// Create a BadRequestObjectResult. /// </summary> /// <param name="message">The error message.</param> /// <param name="exception">The exception.</param> /// <returns>A BadRequestObjectResult.</returns> private static BadRequestObjectResult CreateBadRequestResult(string message, Exception exception) { SerializableError error = CreateErrorResponse(message, exception); return(new BadRequestObjectResult(error)); }
public async Task CreateUser_ResponseStatus_400(CreateUserProfileRequest request, SerializableError expectedResult) { // Arrange var mockUserProfileService = new Mock <IUserProfileService>(); var userProfileEntity = Mapper.Map <UserProfileEntity>(request); mockUserProfileService.Setup(x => x.CreateUserAsync(It.IsAny <UserProfileEntity>())).Throws <UserNameExistsException>(); var userController = new UserController(Mapper, mockUserProfileService.Object, null, null); MockModelState(request, userController); // Act var response = await userController.CreateUser(request); // Assert var badObjectResult = Assert.IsType <BadRequestObjectResult>(response.Result); var result = Assert.IsType <SerializableError>(badObjectResult.Value); Assert.Equal(expectedResult, result); }