public OnActionExecuting ( HttpActionContext actionContext ) : void | ||
actionContext | HttpActionContext | |
리턴 | void |
public void ValidateModelNotValid() { var actionContext = GetContext(true); var sa = new ValidateModelAttribute(); sa.OnActionExecuting(actionContext); var result = actionContext.Result as BadRequestObjectResult; Assert.NotNull(result); var errorDictionary = result.Value as SerializableError; Assert.NotNull(errorDictionary); Assert.True(errorDictionary.ContainsKey("P1")); Assert.True(errorDictionary.ContainsKey("P2")); var p1 = errorDictionary["P1"] as string[]; Assert.NotNull(p1); Assert.AreEqual(1, p1.Length); Assert.AreEqual("bad", p1[0]); var p2 = errorDictionary["P2"] as string[]; Assert.NotNull(p2); Assert.AreEqual(1, p2.Length); Assert.AreEqual("worse", p2[0]); }
public void WhenInvalidModelState_Then_ReturnBadRequest() { //arrange var modelState = new ModelStateDictionary(); modelState.AddModelError("", "error"); var httpContext = new DefaultHttpContext(); var context = new ActionExecutingContext( new ActionContext( httpContext: httpContext, routeData: new RouteData(), actionDescriptor: new ActionDescriptor(), modelState: modelState ), new List <IFilterMetadata>(), new Dictionary <string, object>(), new Mock <Controller>().Object); var sut = new ValidateModelAttribute(); //act sut.OnActionExecuting(context); //assert context.Result.Should().NotBeNull() .And.BeOfType <BadRequestObjectResult>(); }
public void OnActionExecuting_NullOrEmptyArray_ReturnsBadRequestEmptyArray(CalculationTestModel data) { // Arrange var expectedResult = Helper.GetBadRequestResult(Constant.Exception_EmptyArray); var httpContext = new DefaultHttpContext(); var context = new ActionExecutingContext( new ActionContext( httpContext: httpContext, routeData: new RouteData(), actionDescriptor: new ActionDescriptor() ), new List <IFilterMetadata>(), new Dictionary <string, object>() { { "numbers", data.Input } }, new Mock <Controller>().Object); var sut = new ValidateModelAttribute(); //Act sut.OnActionExecuting(context); //Assert Assert.True(expectedResult.IsEqual(context.Result)); }
public void OnActionExecutingSetsBadRequestResponseWhenModelIsInvalidTest() { var httpContext = Substitute.For <HttpContext>(); var routeData = new RouteData(); var actionDescriptor = new ActionDescriptor(); var actionContext = new ActionContext(httpContext, routeData, actionDescriptor); var filters = new List <IFilterMetadata>(); var arguments = new Dictionary <string, object>(); var executingContext = new ActionExecutingContext(actionContext, filters, arguments, null); var request = Substitute.For <HttpRequest>(); var context = Substitute.For <HttpContext>(); request.Method = HttpMethod.Post.ToString(); context.Request.Returns(request); executingContext.HttpContext = context; executingContext.ModelState.AddModelError(Guid.NewGuid().ToString(), Guid.NewGuid().ToString()); var target = new ValidateModelAttribute(); target.OnActionExecuting(executingContext); executingContext.Result.Should().NotBeNull(); executingContext.Result.Should().BeOfType <BadRequestObjectResult>(); executingContext.Result.As <BadRequestObjectResult>().StatusCode.Should().Be((int)HttpStatusCode.BadRequest); }
public void OnActionExecuting_ReturnsOK(CalculationTestModel data) { // Arrange IActionResult expectedResult = null; var httpContext = new DefaultHttpContext(); var context = new ActionExecutingContext( new ActionContext( httpContext: httpContext, routeData: new RouteData(), actionDescriptor: new ActionDescriptor() ), new List <IFilterMetadata>(), new Dictionary <string, object>() { { "numbers", data.Input } }, new Mock <Controller>().Object); var sut = new ValidateModelAttribute(); //Act sut.OnActionExecuting(context); //Assert Assert.True(expectedResult.IsEqual(context.Result)); }
public void ValidateModelAttribute_WithError_ShouldThrowsException() { //Arrange var httpContext = new DefaultHttpContext(); var context = new ActionExecutingContext( new ActionContext { HttpContext = httpContext, RouteData = new RouteData(), ActionDescriptor = new ActionDescriptor(), }, new List <IFilterMetadata>(), new Dictionary <string, object>(), new Mock <Controller>().Object); context.ModelState.AddModelError("", "Error"); var filter = new ValidateModelAttribute(); //Act filter.OnActionExecuting(context); //Assert Assert.IsNotNull(context.Result); Assert.IsInstanceOfType(context.Result, typeof(IActionResult)); }
public void ItReturnsBadObjectResult() { // Arrange var validateModelAttribute = new ValidateModelAttribute(); var modelState = new ModelStateDictionary(); modelState.AddModelError("name", "invalid"); var actionContext = new ActionContext( new Mock <HttpContext>().Object, new Mock <RouteData>().Object, new Mock <ActionDescriptor>().Object, modelState); var actionExcecutingContext = new ActionExecutingContext( actionContext, new List <IFilterMetadata>(), new Dictionary <string, object>(), new Mock <Controller>()); // Act validateModelAttribute.OnActionExecuting(actionExcecutingContext); // Assert Assert.IsType <BadRequestObjectResult>(actionExcecutingContext.Result); }
public void ShouldNotChangeResultIfValidModel([Frozen]ControllerBase controller, [Substitute]ActionExecutingContext filterContext, ValidateModelAttribute validateModel) { filterContext.Controller = controller; validateModel.OnActionExecuting(filterContext); filterContext.Result.Should().BeNull(); }
public void ShouldNotChangeResultIfValidModel([Frozen] ControllerBase controller, [Substitute] ActionExecutingContext filterContext, ValidateModelAttribute validateModel) { filterContext.Controller = controller; validateModel.OnActionExecuting(filterContext); filterContext.Result.Should().BeNull(); }
public void OnActionExecutingThrowsExceptionWithNullContextTest() { var target = new ValidateModelAttribute(); Action action = () => target.OnActionExecuting(null); action.Should().Throw <ArgumentNullException>(); }
public void OnActionExecuting_Valid_Works() { var attribute = new ValidateModelAttribute(); attribute.OnActionExecuting(this.actionContext); Assert.Null(this.actionContext.Response); }
public void ValidateModelValid() { var actionContext = GetContext(false); var sa = new ValidateModelAttribute(); sa.OnActionExecuting(actionContext); Assert.Null(actionContext.Result); }
public void ShouldChangeResultIfInvalidModel([Frozen]ControllerBase controller, [Substitute]ActionExecutingContext filterContext, ValidateModelAttribute validateModel) { filterContext.Controller = controller; filterContext.Controller.ViewData.ModelState.AddModelError("error","error"); validateModel.OnActionExecuting(filterContext); filterContext.Result.Should().BeOfType<ViewResult>().Which.ViewData.ShouldBeEquivalentTo(filterContext.Controller.ViewData); }
public void ShouldChangeResultIfInvalidModel([Frozen] ControllerBase controller, [Substitute] ActionExecutingContext filterContext, ValidateModelAttribute validateModel) { filterContext.Controller = controller; filterContext.Controller.ViewData.ModelState.AddModelError("error", "error"); validateModel.OnActionExecuting(filterContext); filterContext.Result.Should().BeOfType <ViewResult>().Which.ViewData.ShouldBeEquivalentTo(filterContext.Controller.ViewData); }
public void ShouldTestThatErrorResponseIsNotSetWhenModelStateIsValid() { // Arrange var contextMock = GetMockedActionContext(); var filter = new ValidateModelAttribute(); // Act filter.OnActionExecuting(contextMock); // Assert contextMock.Response.Should().BeNull(); }
public void ModelStateIsValid_DoesNotSetResponse() { // Arrange var validate = new ValidateModelAttribute(); var actionContext = new HttpActionContext(); // Act validate.OnActionExecuting(actionContext); // Assert Assert.Null(actionContext.Response); }
public void OnActionExecuting_Invalid_Works() { var attribute = new ValidateModelAttribute(); this.actionContext.ModelState.AddModelError("Name", "Name is required"); attribute.OnActionExecuting(this.actionContext); Assert.Equal(HttpStatusCode.BadRequest, this.actionContext.Response.StatusCode); var error = Assert.IsType <ObjectContent <HttpError> >(this.actionContext.Response.Content); var modelState = JsonConvert.SerializeObject(error.Value); Assert.NotNull(modelState); }
public void OnActionExecuting_Result_is_null() { _systemUnderTest = new ValidateModelAttribute(); var modelStateDictionary = new ModelStateDictionary(); var actionContext = new TestActionContext(modelStateDictionary); var actionExecutingContext = new ActionExecutingContext(actionContext, new List <IFilterMetadata>(), new Dictionary <string, object>(), null); _systemUnderTest.OnActionExecuting(actionExecutingContext); Assert.IsNull(actionExecutingContext.Result); _systemUnderTest.OnActionExecuted(new ActionExecutedContext(actionContext, new List <IFilterMetadata>(), null)); Assert.IsNull(actionExecutingContext.Result); }
public void OnActionExecuting_Result_returns_BadRequestObjectResult() { _systemUnderTest = new ValidateModelAttribute(); var modelStateDictionary = new ModelStateDictionary(); var actionContext = new TestActionContext(modelStateDictionary); var actionExecutingContext = new ActionExecutingContext(actionContext, new List <IFilterMetadata>(), new Dictionary <string, object>(), null); modelStateDictionary.AddModelError("name", "IsInvalid"); _systemUnderTest.OnActionExecuting(actionExecutingContext); Assert.IsAssignableFrom <BadRequestObjectResult>(actionExecutingContext.Result); }
public void OnActionExecuting_SetsBadRequestResult() { var modelState = new ModelStateDictionary(); modelState.AddModelError("Error", "Error"); var actionContext = new ActionContext( new Mock <HttpContext>().Object, new Mock <RouteData>().Object, new Mock <ActionDescriptor>().Object, modelState); var executingContext = new ActionExecutingContext( actionContext, new List <IFilterMetadata>(), new Dictionary <string, object>(), new Mock <Controller>()); _attribute.OnActionExecuting(executingContext); executingContext.Result.Should().NotBeNull(); executingContext.Result.Should().BeOfType <BadRequestObjectResult>(); }
public void ModelStateIsInvalid_SetsErrorResponse() { // Arrange var validate = new ValidateModelAttribute(); var request = new HttpRequestMessage(); var actionContext = ContextUtil.GetHttpActionContext(request); actionContext.ModelState.AddModelError("myKey", "myError"); // Act validate.OnActionExecuting(actionContext); // Assert var response = actionContext.Response; Assert.NotNull(response); Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); }
public void OnActionExecutingHasNoEffectWhenModelStateIsValidTest() { var httpContext = Substitute.For <HttpContext>(); var routeData = new RouteData(); var actionDescriptor = new ActionDescriptor(); var actionContext = new ActionContext(httpContext, routeData, actionDescriptor); var filters = new List <IFilterMetadata>(); var arguments = new Dictionary <string, object>(); var executingContext = new ActionExecutingContext(actionContext, filters, arguments, null); var request = Substitute.For <HttpRequest>(); request.Method = HttpMethod.Post.ToString(); httpContext.Request.Returns(request); var target = new ValidateModelAttribute(); target.OnActionExecuting(executingContext); executingContext.Result.Should().BeNull(); }
public void ValidateModelAttributeShould() { var modelState = new ModelStateDictionary(); modelState.AddModelError("", "error"); var httpContext = new DefaultHttpContext(); var context = new ActionExecutingContext( new ActionContext( httpContext, new RouteData(), new ActionDescriptor(), modelState ), new List <IFilterMetadata>(), new Dictionary <string, object>(), new Mock <Controller>().Object); var sut = new ValidateModelAttribute(); Assert.Throws <InputParameterIsNotCorrect>(() => sut.OnActionExecuting(context)); }
public void OnActionExecutingValidInput() { var modelState = new ModelStateDictionary(); var actionContext = new ActionContext( Mock.Of <HttpContext>(), Mock.Of <RouteData>(), Mock.Of <ActionDescriptor>(), modelState); var actionExecutingContext = new ActionExecutingContext( actionContext, new List <IFilterMetadata>(), new Dictionary <string, object>(), Mock.Of <Controller>()); ValidateModelAttribute validateModelAttribute = new ValidateModelAttribute(this.logger); validateModelAttribute.OnActionExecuting(actionExecutingContext); Assert.IsNull(actionExecutingContext.Result); }
public void Test_ValidateModelAttribute_Invoke(string key, string message) { // Arrange var serviceProviderMock = new Mock <IServiceProvider>(); serviceProviderMock.Setup(serviceProvider => serviceProvider.GetService(typeof(ILogger <ValidateModelAttribute>))) .Returns(Mock.Of <ILogger <ValidateModelAttribute> >()); var httpContext = new DefaultHttpContext { RequestServices = serviceProviderMock.Object }; var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor()); var actionExecutingContext = new ActionExecutingContext(actionContext, filters: new List <IFilterMetadata>(), // for majority of scenarios you need not worry about populating this parameter actionArguments: new Dictionary <string, object>(), // if the filter uses this data, add some data to this dictionary controller: null); // since the filter being tested here does not use the data from this parameter, just provide null var validationFilter = new ValidateModelAttribute(); // Act actionContext.ModelState.AddModelError(key, message); validationFilter.OnActionExecuting(actionExecutingContext); var validationResult = Assert.IsType <ValidationFailedResult>(actionExecutingContext.Result); // Assert validationResult.StatusCode.Should().Be(400); var errorResult = Assert.IsType <ApiErrorResult>(validationResult.Value); errorResult.Message.Should().Be("Validation Error"); errorResult.Errors.Count.Should().Be(1); errorResult.Errors[0].Message.Should().Be(message); errorResult.Errors[0].Field.Should().Be(key); }
public void OnActionExecutingInvalidInput() { var modelState = new ModelStateDictionary(); modelState.AddModelError("name", "invalid"); var actionContext = new ActionContext( Mock.Of <HttpContext>(), Mock.Of <RouteData>(), Mock.Of <ActionDescriptor>(), modelState); var actionExecutingContext = new ActionExecutingContext( actionContext, new List <IFilterMetadata>(), new Dictionary <string, object>(), Mock.Of <Controller>()); ValidateModelAttribute validateModelAttribute = new ValidateModelAttribute(this.logger); validateModelAttribute.OnActionExecuting(actionExecutingContext); Assert.IsInstanceOf <BadRequestObjectResult>(actionExecutingContext.Result); }
public void ShouldNotReturnBadRequestObjectResultIfModelStateIsValid() { _validateModelAttribute.OnActionExecuting(_actionContextMock); Assert.IsNull(_actionContextMock.Result); }
public void OnActionExecuting_ShouldNotChangeContextResultIfModelStateIsValid() { _validateModelAttribute.OnActionExecuting(_actionContextMock); Assert.IsNull(_actionContextMock.Result); }
private void OnActionExecuting_OnNoModelErrorsAndNotNull_ResultIsNull() { _filter.OnActionExecuting(_actionExecutingContext); Assert.Null(_actionExecutingContext.Result); }