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 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 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 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 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 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 ReturnsValidateModelAttribute()
{
// Arrange -> Act
var validate = new ValidateModelAttribute();
// Assert
Assert.IsAssignableFrom <ValidateModelAttribute>(validate);
}
public void OnActionExecutingThrowsExceptionWithNullContextTest()
{
var target = new ValidateModelAttribute();
Action action = () => target.OnActionExecuting(null);
action.Should().Throw <ArgumentNullException>();
}
public void ShouldNotChangeResultIfValidModel([Frozen]ControllerBase controller, [Substitute]ActionExecutingContext filterContext, ValidateModelAttribute validateModel)
{
filterContext.Controller = controller;
validateModel.OnActionExecuting(filterContext);
filterContext.Result.Should().BeNull();
}
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 ValidateModelAttributeTests()
{
_modelState = new ModelStateDictionary();
_actionArguments = new Dictionary <string, object>()
{
{ "name", "Pszemek" }
};
_actionContextMock = GetActionContext();
_actionExecutingContext = GetActionExecutingContext();
_filter = new ValidateModelAttribute();
}
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 SetUp()
{
_actionContextMock = new ActionExecutingContext(
new ActionContext {
HttpContext = new DefaultHttpContext(),
RouteData = new RouteData(),
ActionDescriptor = new ActionDescriptor(),
},
new List <IFilterMetadata>(),
new Dictionary <string, object>(),
new Mock <Controller>().Object);
_validateModelAttribute = new ValidateModelAttribute();
}
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 OnResultExecuting_Should_Set_Result_As_BadRequest_For_Model_Errors()
{
var context = new ResultExecutingContext(_actionContext, Enumerable.Empty <IFilterMetadata>().ToList(),
new ContentResult(), new { });
var validateModelAttribute = new ValidateModelAttribute();
context.ModelState.AddModelError("testError", "errorMessage");
validateModelAttribute.OnResultExecutionAsync(context, null);
context.Result.Should().BeOfType(typeof(BadRequestObjectResult));
var badresult = (BadRequestObjectResult)context.Result;
badresult.Value.Should().NotBeNull();
badresult.Value.Should().BeOfType(typeof(ResultContent <>));
var resultContent = (ResultContent <string>)badresult.Value;
resultContent.StatusCode.Should().Be(HttpStatusCode.BadRequest);
resultContent.ContentModel.Should().BeNull();
resultContent.PropertyMessages.Should().NotBeEmpty();
resultContent.PropertyMessages.Should().ContainKey("testError");
resultContent.PropertyMessages.Count.Should().BeGreaterOrEqualTo(1);
}
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 ShouldNotChangeResultIfValidModel([Frozen] ControllerBase controller, [Substitute] ActionExecutingContext filterContext, ValidateModelAttribute validateModel)
{
filterContext.Controller = controller;
validateModel.OnActionExecuting(filterContext);
filterContext.Result.Should().BeNull();
}
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);
}
