public void CreateRequestModel_should_create_a_command_request_model_from_the_http_request_body()
{
// Given an HttpRequest with a json message in the body
HttpContext httpContext = new DefaultHttpContext();
httpContext.Request.Method = "POST";
httpContext.Request.ContentType = "application/json";
httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("{ name: 'Bar', ranking: 10 }"));
// Plus some empty route data
RouteData routeData = new RouteData();
// When I try to bind to a request model
IInputFormatter inputFormatter = new JsonInputFormatter();
IEnumerable <IValueParser> valueParsers = new List <IValueParser> {
new RouteValueParser(routeData)
};
RequestModelActivator modelActivator = new RequestModelActivator(httpContext, inputFormatter, valueParsers);
var requestModel = modelActivator.CreateRequestModelAsync <Foo>().Result;
// Then the result should be an instance of Foo with all of it's properties set correctly
Foo result = requestModel;
Assert.Equal("Bar", result?.Name);
Assert.Equal(10, result?.Ranking);
}
public void CreateRequestModel_should_merge_message_body_and_route_data_to_create_a_command_request_model()
{
// Given an HttpRequest with a json message in the body
HttpContext httpContext = new DefaultHttpContext();
httpContext.Request.Method = "POST";
httpContext.Request.ContentType = "application/json";
httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes("{ name: 'Bar', ranking: 10 }"));
// Plus some route data
RouteData routeData = new RouteData();
routeData.Values.Add("Ranking", "42");
// When I try to bind to a request model
IInputFormatter inputFormatter = new JsonInputFormatter();
IEnumerable <IValueParser> valueParsers = new List <IValueParser> {
new RouteValueParser(routeData)
};
RequestModelActivator modelActivator = new RequestModelActivator(httpContext, inputFormatter, valueParsers);
var requestModel = modelActivator.CreateRequestModelAsync <Foo>().Result;
// Then the result should be an instance of Foo with all of it's properties set correctly
// from a combination of the message body and the route data
Foo result = requestModel;
result?.Name.Should().Be("Bar");
result?.Ranking.Should().Be(42);
}
public void BindRequestParameters_should_create_a_command_request_model_from_parameters_in_route_template()
{
// Given an HttpRequest with an empty body
HttpContext httpContext = new DefaultHttpContext();
httpContext.Request.Method = "GET";
httpContext.Request.ContentType = "application/json";
httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(""));
// And some model properties in the route data
RouteData routeData = new RouteData();
routeData.Values.Add("name", "Bar");
routeData.Values.Add("Ranking", "10");
// When I try to bind to a request model
IInputFormatter inputFormatter = new JsonInputFormatter();
IEnumerable <IValueParser> valueParsers = new List <IValueParser> {
new RouteValueParser(routeData)
};
RequestModelActivator modelActivator = new RequestModelActivator(httpContext, inputFormatter, valueParsers);
var requestModel = modelActivator.CreateRequestModelAsync <Foo>().Result;
// Then the result should be an instance of Foo with all of it's properties set correctly
Foo result = requestModel;
Assert.Equal("Bar", result?.Name);
Assert.Equal(10, result?.Ranking);
}
public async Task RouteAsync(RouteContext context)
{
// Build a request model from the request
IInputFormatter inputFormatter = new JsonInputFormatter();
IEnumerable <IValueParser> valueParsers = new List <IValueParser> {
new RouteValueParser(context.RouteData)
};
RequestModelActivator modelActivator = new RequestModelActivator(
context.HttpContext,
inputFormatter,
valueParsers
);
TRequest requestModel = await modelActivator.CreateRequestModelAsync <TRequest>();
// Run the request through our command pipeline
IHandlerResult pipelineResult = _pipeline.Dispatch(context.HttpContext, requestModel);
// If the request was handled by our pipeline then write the response out
if (pipelineResult.IsHandled)
{
// Serialize the response model
IOutputFormatter outputFormatter = new JsonOutputFormatter();
ResponseWriter responseWriter = new ResponseWriter(context.HttpContext, outputFormatter);
await responseWriter.SerializeResponseAsync(pipelineResult);
// Let OWIN know our middleware handled the request
context.IsHandled = true;
}
}
public void InputFormatters_InstancesOf_ReturnsNonEmptyCollectionIfSomeExist()
{
// Arrange
var formatters = new MvcOptions().InputFormatters;
formatters.Add(typeof(JsonInputFormatter));
var formatter1 = new JsonInputFormatter();
var formatter2 = Mock.Of <IInputFormatter>();
var formatter3 = new JsonInputFormatter();
var formatter4 = Mock.Of <IInputFormatter>();
formatters.Add(formatter1);
formatters.Add(formatter2);
formatters.Add(formatter3);
formatters.Add(formatter4);
var expectedFormatters = new List <JsonInputFormatter> {
formatter1, formatter3
};
// Act
var jsonFormatters = formatters.InstancesOf <JsonInputFormatter>().ToList();
// Assert
Assert.NotEmpty(jsonFormatters);
Assert.Equal(jsonFormatters, expectedFormatters);
}
public static void AddEmptyContentTypeFormatter(this MvcOptions options)
{
_ = options ?? throw new ArgumentNullException(nameof(options));
JsonInputFormatter formatter = (JsonInputFormatter)options.InputFormatters.First(f => f.GetType() == typeof(JsonInputFormatter));
options.InputFormatters.Add(new EmptyContentTypeJsonInputFormatter(formatter));
}
public MyModelBinder(IHttpRequestStreamReaderFactory readerFactory, ILoggerFactory loggerFactory, IOptions <MvcOptions> options, IOptions <MvcJsonOptions> jsonOptions, ArrayPool <char> charPool, ObjectPoolProvider objectPoolProvider)
{
var formatters = options.Value.InputFormatters.ToList();
int jsonFormatterIndex = formatters.FirstIndexOf(formatter => formatter is JsonInputFormatter);
JsonSerializerSettings myCustomSettings = ...
formatters[jsonFormatterIndex] = new JsonInputFormatter(loggerFactory.CreateLogger("MyCustomJsonFormatter"), myCustomSettings, charPool, objectPoolProvider, options.Value, jsonOptions.Value);
_bodyModelBinder = new BodyModelBinder(formatters, readerFactory, loggerFactory, options.Value);
}
public void Constructor_UsesSerializerSettings()
{
// Arrange
// Act
var serializerSettings = new JsonSerializerSettings();
var jsonFormatter = new JsonInputFormatter(serializerSettings);
// Assert
Assert.Same(serializerSettings, jsonFormatter.SerializerSettings);
}
public void Constructor_UsesSerializerSettings()
{
// Arrange
// Act
var serializerSettings = new JsonSerializerSettings();
var jsonFormatter = new JsonInputFormatter(serializerSettings);
// Assert
Assert.Same(serializerSettings, jsonFormatter.SerializerSettings);
}
public static void UseHtmlEncodeJsonInputFormatter(this MvcOptions opts, ILogger <MvcOptions> logger, ObjectPoolProvider objectPoolProvider)
{
opts.InputFormatters.RemoveType <JsonInputFormatter>();
var serializerSettings = new JsonSerializerSettings
{
ContractResolver = new HtmlEncodeContractResolver()
};
var jsonInputFormatter = new JsonInputFormatter(logger, serializerSettings, ArrayPool <char> .Shared, objectPoolProvider);
opts.InputFormatters.Add(jsonInputFormatter);
}
public void DefaultMediaType_ReturnsApplicationJson()
{
// Arrange
var formatter = new JsonInputFormatter();
// Act
var mediaType = formatter.SupportedMediaTypes[0];
// Assert
Assert.Equal("application/json", mediaType.ToString());
}
public ToUppercaseJsonInputFormatter(JsonInputFormatter jsonInputFormatter)
{
_jsonInputFormatter = jsonInputFormatter;
foreach (var supportedEncoding in _jsonInputFormatter.SupportedEncodings)
{
SupportedEncodings.Add(supportedEncoding);
}
foreach (var supportedMediaType in _jsonInputFormatter.SupportedMediaTypes)
{
SupportedMediaTypes.Add(supportedMediaType);
}
}
public void CanRead_ReturnsTrueForAnySupportedContentType(string requestContentType, bool expectedCanRead)
{
// Arrange
var formatter = new JsonInputFormatter();
var contentBytes = Encoding.UTF8.GetBytes("content");
var actionContext = GetActionContext(contentBytes, contentType: requestContentType);
var formatterContext = new InputFormatterContext(actionContext, typeof(string));
// Act
var result = formatter.CanRead(formatterContext);
// Assert
Assert.Equal(expectedCanRead, result);
}
public async Task JsonFormatterReadsSimpleTypes(string content, Type type, object expected)
{
// Arrange
var formatter = new JsonInputFormatter();
var contentBytes = Encoding.UTF8.GetBytes(content);
var actionContext = GetActionContext(contentBytes);
var context = new InputFormatterContext(actionContext, type);
// Act
var model = await formatter.ReadAsync(context);
// Assert
Assert.Equal(expected, model);
}
public void InputFormatters_InstanceOf_ReturnsInstanceOfIInputFormatterIfOneExists()
{
// Arrange
var formatters = new MvcOptions().InputFormatters;
formatters.Add(Mock.Of<IInputFormatter>());
var jsonFormatter = new JsonInputFormatter();
formatters.Add(jsonFormatter);
formatters.Add(typeof(JsonInputFormatter));
// Act
var formatter = formatters.InstanceOf<JsonInputFormatter>();
// Assert
Assert.NotNull(formatter);
Assert.IsType<JsonInputFormatter>(formatter);
Assert.Same(jsonFormatter, formatter);
}
public static IMvcCoreBuilder AddGitLfs(this IMvcCoreBuilder builder)
{
builder.AddJsonFormatters();
builder.AddApplicationPart(typeof(LfsConstants).GetTypeInfo().Assembly);
builder.AddMvcOptions(options =>
{
options.Filters.Add(new ProducesAttribute(LfsConstants.LfsMediaType.MediaType.Buffer));
options.Filters.Add(new TypeFilterAttribute(typeof(BasicAuthFilter)));
JsonOutputFormatter jsonOutput = options.OutputFormatters.OfType <JsonOutputFormatter>().First();
jsonOutput.SupportedMediaTypes.Add(LfsConstants.LfsMediaType);
JsonInputFormatter jsonInput = options.InputFormatters.OfType <JsonInputFormatter>().First();
jsonInput.SupportedMediaTypes.Add(LfsConstants.LfsMediaType);
});
return(builder);
}
public void InputFormatters_InstanceOfOrDefault_ReturnsInstanceOfIInputFormatterIfOneExists()
{
// Arrange
var formatters = new MvcOptions().InputFormatters;
formatters.Add(Mock.Of <IInputFormatter>());
formatters.Add(typeof(JsonInputFormatter));
var jsonFormatter = new JsonInputFormatter();
formatters.Add(jsonFormatter);
// Act
var formatter = formatters.InstanceOfOrDefault <JsonInputFormatter>();
// Assert
Assert.NotNull(formatter);
Assert.IsType <JsonInputFormatter>(formatter);
Assert.Same(jsonFormatter, formatter);
}
public void CanRead_ReturnsTrueForAnySupportedContentType(string requestContentType, bool expectedCanRead)
{
// Arrange
var formatter = new JsonInputFormatter();
var contentBytes = Encoding.UTF8.GetBytes("content");
var httpContext = GetHttpContext(contentBytes, contentType: requestContentType);
var formatterContext = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: new ModelStateDictionary(),
modelType: typeof(string));
// Act
var result = formatter.CanRead(formatterContext);
// Assert
Assert.Equal(expectedCanRead, result);
}
public void OnResourceExecuting(ResourceExecutingContext context)
{
// remove existing input formatter and add a new one
var camelcaseInputFormatter = new JsonInputFormatter(serializerSettings);
var inputFormatter = context.InputFormatters.FirstOrDefault(frmtr => frmtr is JsonInputFormatter);
if (inputFormatter != null)
{
context.InputFormatters.Remove(inputFormatter);
context.InputFormatters.Add(camelcaseInputFormatter);
}
// remove existing output formatter and add a new one
var camelcaseOutputFormatter = new JsonOutputFormatter(serializerSettings);
var outputFormatter = context.OutputFormatters.FirstOrDefault(frmtr => frmtr is JsonOutputFormatter);
if (outputFormatter != null)
{
context.OutputFormatters.Remove(outputFormatter);
context.OutputFormatters.Add(camelcaseOutputFormatter);
}
}
public async Task JsonFormatterReadsSimpleTypes(string content, Type type, object expected)
{
// Arrange
var formatter = new JsonInputFormatter();
var contentBytes = Encoding.UTF8.GetBytes(content);
var httpContext = GetHttpContext(contentBytes);
var context = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: new ModelStateDictionary(),
modelType: type);
// Act
var result = await formatter.ReadAsync(context);
// Assert
Assert.False(result.HasError);
Assert.Equal(expected, result.Model);
}
public void OnResourceExecuting(ResourceExecutingContext context)
{
var mobileInputFormatter = new JsonInputFormatter(serializerSettings);
var inputFormatter = context.InputFormatters.FirstOrDefault(frmtr => frmtr is JsonInputFormatter);
if (inputFormatter != null)
{
context.InputFormatters.Remove(inputFormatter);
}
context.InputFormatters.Add(mobileInputFormatter);
var mobileOutputFormatter = new JsonOutputFormatter(serializerSettings);
var outputFormatter = context.OutputFormatters.FirstOrDefault(frmtr => frmtr is JsonOutputFormatter);
if (outputFormatter != null)
{
context.OutputFormatters.Remove(outputFormatter);
}
context.OutputFormatters.Add(mobileOutputFormatter);
}
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
services.Configure <MvcOptions>(options =>
{
options.InputFormatters.Clear();
var jsonInputFormatter = new JsonInputFormatter();
jsonInputFormatter.SupportedMediaTypes.Clear();
jsonInputFormatter.SupportedMediaTypes.Add(JsonMediaType);
options.InputFormatters.Add(jsonInputFormatter);
var xmlSerializerInputFormatter = new XmlSerializerInputFormatter();
xmlSerializerInputFormatter.SupportedMediaTypes.Clear();
xmlSerializerInputFormatter.SupportedMediaTypes.Add(XmlSerializerMediaType);
options.InputFormatters.Add(xmlSerializerInputFormatter);
var xmlDataContractSerializerInputFormatter = new XmlDataContractSerializerInputFormatter();
xmlDataContractSerializerInputFormatter.SupportedMediaTypes.Clear();
xmlDataContractSerializerInputFormatter.SupportedMediaTypes.Add(XmlDataContractSerializerMediaType);
options.InputFormatters.Add(xmlDataContractSerializerInputFormatter);
options.OutputFormatters.Clear();
var jsonOutputFormatter = new JsonOutputFormatter();
jsonOutputFormatter.SupportedMediaTypes.Clear();
jsonOutputFormatter.SupportedMediaTypes.Add(JsonMediaType);
options.OutputFormatters.Add(jsonOutputFormatter);
var xmlSerializerOutputFormatter = new XmlSerializerOutputFormatter();
xmlSerializerOutputFormatter.SupportedMediaTypes.Clear();
xmlSerializerOutputFormatter.SupportedMediaTypes.Add(XmlSerializerMediaType);
options.OutputFormatters.Add(xmlSerializerOutputFormatter);
var xmlDataContractSerializerOutputFormatter = new XmlDataContractSerializerOutputFormatter();
xmlDataContractSerializerOutputFormatter.SupportedMediaTypes.Clear();
xmlDataContractSerializerOutputFormatter.SupportedMediaTypes.Add(XmlDataContractSerializerMediaType);
options.OutputFormatters.Add(xmlDataContractSerializerOutputFormatter);
});
}
private static void SetupMvcOptions(MvcOptions setupAction)
{
setupAction.ReturnHttpNotAcceptable = true;
setupAction.OutputFormatters.Add(new XmlDataContractSerializerOutputFormatter());
XmlDataContractSerializerInputFormatter xmlDataContractSerializerInputFormatter =
new XmlDataContractSerializerInputFormatter();
xmlDataContractSerializerInputFormatter.SupportedMediaTypes.Add(
"application/vnd.marvin.authorwithdateofdeath.full+xml");
setupAction.InputFormatters.Add(xmlDataContractSerializerInputFormatter);
JsonOutputFormatter jsonOutputFormatter =
setupAction.OutputFormatters.OfType <JsonOutputFormatter>().FirstOrDefault();
jsonOutputFormatter?.SupportedMediaTypes.Add(VendorMediaType);
JsonInputFormatter jsonInputFormatter =
setupAction.InputFormatters.OfType <JsonInputFormatter>().FirstOrDefault();
jsonInputFormatter?.SupportedMediaTypes.Add("application/vnd.marvin.author.full+json");
jsonInputFormatter?.SupportedMediaTypes.Add("application/vnd.marvin.authorwithdateofdeath.full+json");
}
public void CanRead_ReturnsTrueForAnySupportedContentType(string requestContentType, bool expectedCanRead)
{
// Arrange
var loggerMock = GetLogger();
var formatter = new JsonInputFormatter(loggerMock);
var contentBytes = Encoding.UTF8.GetBytes("content");
var httpContext = GetHttpContext(contentBytes, contentType: requestContentType);
var provider = new EmptyModelMetadataProvider();
var metadata = provider.GetMetadataForType(typeof(string));
var formatterContext = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: new ModelStateDictionary(),
metadata: metadata,
readerFactory: new TestHttpRequestStreamReaderFactory().CreateReader);
// Act
var result = formatter.CanRead(formatterContext);
// Assert
Assert.Equal(expectedCanRead, result);
}
public async Task JsonFormatterReadsComplexTypes()
{
// Arrange
var content = "{name: 'Person Name', Age: '30'}";
var formatter = new JsonInputFormatter();
var contentBytes = Encoding.UTF8.GetBytes(content);
var actionContext = GetActionContext(contentBytes);
var metadata = new EmptyModelMetadataProvider().GetMetadataForType(typeof(User));
var context = new InputFormatterContext(actionContext, metadata.ModelType);
// Act
var model = await formatter.ReadAsync(context);
// Assert
var userModel = Assert.IsType<User>(model);
Assert.Equal("Person Name", userModel.Name);
Assert.Equal(30, userModel.Age);
}
public async Task JsonFormatterReadsComplexTypes()
{
// Arrange
var content = "{name: 'Person Name', Age: '30'}";
var logger = GetLogger();
var formatter = new JsonInputFormatter(logger);
var contentBytes = Encoding.UTF8.GetBytes(content);
var httpContext = GetHttpContext(contentBytes);
var provider = new EmptyModelMetadataProvider();
var metadata = provider.GetMetadataForType(typeof(User));
var context = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: new ModelStateDictionary(),
metadata: metadata,
readerFactory: new TestHttpRequestStreamReaderFactory().CreateReader);
// Act
var result = await formatter.ReadAsync(context);
// Assert
Assert.False(result.HasError);
var userModel = Assert.IsType<User>(result.Model);
Assert.Equal("Person Name", userModel.Name);
Assert.Equal(30, userModel.Age);
}
public async Task ReadAsync_AddsModelValidationErrorsToModelState()
{
// Arrange
var content = "{name: 'Person Name', Age: 'not-an-age'}";
var logger = GetLogger();
var formatter = new JsonInputFormatter(logger);
var contentBytes = Encoding.UTF8.GetBytes(content);
var modelState = new ModelStateDictionary();
var httpContext = GetHttpContext(contentBytes);
var provider = new EmptyModelMetadataProvider();
var metadata = provider.GetMetadataForType(typeof(User));
var context = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: modelState,
metadata: metadata,
readerFactory: new TestHttpRequestStreamReaderFactory().CreateReader);
// Act
var result = await formatter.ReadAsync(context);
// Assert
Assert.True(result.HasError);
Assert.Equal(
"Could not convert string to decimal: not-an-age. Path 'Age', line 1, position 39.",
modelState["Age"].Errors[0].Exception.Message);
}
public EmptyContentTypeJsonInputFormatter(JsonInputFormatter inner)
{
_inner = inner ?? throw new ArgumentNullException(nameof(inner));
}
public async Task CustomSerializerSettingsObject_TakesEffect()
{
// Arrange
// missing password property here
var contentBytes = Encoding.UTF8.GetBytes("{ \"UserName\" : \"John\"}");
var jsonFormatter = new JsonInputFormatter();
// by default we ignore missing members, so here explicitly changing it
jsonFormatter.SerializerSettings = new JsonSerializerSettings()
{
MissingMemberHandling = MissingMemberHandling.Error
};
var modelState = new ModelStateDictionary();
var httpContext = GetHttpContext(contentBytes, "application/json;charset=utf-8");
var inputFormatterContext = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: modelState,
modelType: typeof(UserLogin));
// Act
var result = await jsonFormatter.ReadAsync(inputFormatterContext);
// Assert
Assert.True(result.HasError);
Assert.False(modelState.IsValid);
var modelErrorMessage = modelState.Values.First().Errors[0].Exception.Message;
Assert.Contains("Required property 'Password' not found in JSON", modelErrorMessage);
}
public async Task JsonFormatterReadsSimpleTypes(string content, Type type, object expected)
{
// Arrange
var logger = GetLogger();
var formatter = new JsonInputFormatter(logger);
var contentBytes = Encoding.UTF8.GetBytes(content);
var httpContext = GetHttpContext(contentBytes);
var provider = new EmptyModelMetadataProvider();
var metadata = provider.GetMetadataForType(type);
var context = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: new ModelStateDictionary(),
metadata: metadata,
readerFactory: new TestHttpRequestStreamReaderFactory().CreateReader);
// Act
var result = await formatter.ReadAsync(context);
// Assert
Assert.False(result.HasError);
Assert.Equal(expected, result.Model);
}
public async Task JsonFormatterReadsComplexTypes()
{
// Arrange
var content = "{name: 'Person Name', Age: '30'}";
var formatter = new JsonInputFormatter();
var contentBytes = Encoding.UTF8.GetBytes(content);
var httpContext = GetHttpContext(contentBytes);
var context = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: new ModelStateDictionary(),
modelType: typeof(User));
// Act
var result = await formatter.ReadAsync(context);
// Assert
Assert.False(result.HasError);
var userModel = Assert.IsType<User>(result.Model);
Assert.Equal("Person Name", userModel.Name);
Assert.Equal(30, userModel.Age);
}
public async Task CustomSerializerSettingsObject_TakesEffect()
{
// Arrange
// missing password property here
var contentBytes = Encoding.UTF8.GetBytes("{ \"UserName\" : \"John\"}");
var jsonFormatter = new JsonInputFormatter();
// by default we ignore missing members, so here explicitly changing it
jsonFormatter.SerializerSettings = new JsonSerializerSettings()
{
MissingMemberHandling = MissingMemberHandling.Error
};
var actionContext = GetActionContext(contentBytes, "application/json;charset=utf-8");
var metadata = new EmptyModelMetadataProvider().GetMetadataForType(typeof(UserLogin));
var inputFormatterContext = new InputFormatterContext(actionContext, metadata.ModelType);
// Act
var obj = await jsonFormatter.ReadAsync(inputFormatterContext);
// Assert
Assert.False(actionContext.ModelState.IsValid);
var modelErrorMessage = actionContext.ModelState.Values.First().Errors[0].Exception.Message;
Assert.Contains("Required property 'Password' not found in JSON", modelErrorMessage);
}
public async Task ReadAsync_UsesTryAddModelValidationErrorsToModelState()
{
// Arrange
var content = "{name: 'Person Name', Age: 'not-an-age'}";
var formatter = new JsonInputFormatter();
var contentBytes = Encoding.UTF8.GetBytes(content);
var actionContext = GetActionContext(contentBytes);
var metadata = new EmptyModelMetadataProvider().GetMetadataForType(typeof(User));
var context = new InputFormatterContext(actionContext, metadata.ModelType);
actionContext.ModelState.MaxAllowedErrors = 3;
actionContext.ModelState.AddModelError("key1", "error1");
actionContext.ModelState.AddModelError("key2", "error2");
// Act
var model = await formatter.ReadAsync(context);
// Assert
Assert.False(actionContext.ModelState.ContainsKey("age"));
var error = Assert.Single(actionContext.ModelState[""].Errors);
Assert.IsType<TooManyModelErrorsException>(error.Exception);
}
public async Task ReadAsync_AddsModelValidationErrorsToModelState()
{
// Arrange
var content = "{name: 'Person Name', Age: 'not-an-age'}";
var formatter = new JsonInputFormatter();
var contentBytes = Encoding.UTF8.GetBytes(content);
var actionContext = GetActionContext(contentBytes);
var metadata = new EmptyModelMetadataProvider().GetMetadataForType(typeof(User));
var context = new InputFormatterContext(actionContext, metadata.ModelType);
// Act
var model = await formatter.ReadAsync(context);
// Assert
Assert.Equal("Could not convert string to decimal: not-an-age. Path 'Age', line 1, position 39.",
actionContext.ModelState["Age"].Errors[0].Exception.Message);
}
public async Task ChangesTo_DefaultSerializerSettings_TakesEffect()
{
// Arrange
// missing password property here
var contentBytes = Encoding.UTF8.GetBytes("{ \"UserName\" : \"John\"}");
var logger = GetLogger();
var jsonFormatter = new JsonInputFormatter(logger);
// by default we ignore missing members, so here explicitly changing it
jsonFormatter.SerializerSettings.MissingMemberHandling = MissingMemberHandling.Error;
var modelState = new ModelStateDictionary();
var httpContext = GetHttpContext(contentBytes, "application/json;charset=utf-8");
var provider = new EmptyModelMetadataProvider();
var metadata = provider.GetMetadataForType(typeof(UserLogin));
var inputFormatterContext = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: modelState,
metadata: metadata,
readerFactory: new TestHttpRequestStreamReaderFactory().CreateReader);
// Act
var result = await jsonFormatter.ReadAsync(inputFormatterContext);
// Assert
Assert.True(result.HasError);
Assert.False(modelState.IsValid);
var modelErrorMessage = modelState.Values.First().Errors[0].Exception.Message;
Assert.Contains("Required property 'Password' not found in JSON", modelErrorMessage);
}
// This method gets called by a runtime.
// Use this method to add services to the container
public void ConfigureServices(IServiceCollection services)
{
services.AddLogging();
services.Configure<MvcOptions>(options =>
{
var settings = new JsonSerializerSettings()
{
Formatting = Formatting.Indented,
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new CamelCaseExceptDictionaryKeysResolver()
};
options.InputFormatters.Clear();
options.OutputFormatters.Clear();
var inputFormatter = new JsonInputFormatter(settings);
var outputFormatter = new JsonOutputFormatter(settings);
options.InputFormatters.Insert(0, inputFormatter);
options.OutputFormatters.Insert(0, outputFormatter);
options.ModelBinders.Add(new UserPrincipleModelBinder());
options.Filters.Add(new AuthenticationFilterAttribute() { DataProvider = DataAccessControllerFactory.Provider });
options.Filters.Add(new HandleFinalErrorFilterAttribute());
});
services.AddSingleton<IControllerFactory, DataAccessControllerFactory>();
services.AddMvc();
}
public async Task ReadAsync_UsesTryAddModelValidationErrorsToModelState()
{
// Arrange
var content = "{name: 'Person Name', Age: 'not-an-age'}";
var formatter = new JsonInputFormatter();
var contentBytes = Encoding.UTF8.GetBytes(content);
var modelState = new ModelStateDictionary();
var httpContext = GetHttpContext(contentBytes);
var context = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: modelState,
modelType: typeof(User));
modelState.MaxAllowedErrors = 3;
modelState.AddModelError("key1", "error1");
modelState.AddModelError("key2", "error2");
// Act
var result = await formatter.ReadAsync(context);
// Assert
Assert.True(result.HasError);
Assert.False(modelState.ContainsKey("age"));
var error = Assert.Single(modelState[""].Errors);
Assert.IsType<TooManyModelErrorsException>(error.Exception);
}
public async Task ThrowsException_OnSupplyingNull_ForRequiredValueType()
{
// Arrange
var contentBytes = Encoding.UTF8.GetBytes("{\"Id\":\"null\",\"Name\":\"Programming C#\"}");
var jsonFormatter = new JsonInputFormatter();
var actionContext = GetActionContext(contentBytes, "application/json;charset=utf-8");
var metadata = new EmptyModelMetadataProvider().GetMetadataForType(typeof(Book));
var inputFormatterContext = new InputFormatterContext(actionContext, metadata.ModelType);
// Act
var obj = await jsonFormatter.ReadAsync(inputFormatterContext);
// Assert
var book = obj as Book;
Assert.NotNull(book);
Assert.Equal(0, book.Id);
Assert.Equal("Programming C#", book.Name);
Assert.False(actionContext.ModelState.IsValid);
Assert.Equal(1, actionContext.ModelState.Values.First().Errors.Count);
var modelErrorMessage = actionContext.ModelState.Values.First().Errors[0].Exception.Message;
Assert.Contains("Could not convert string to integer: null. Path 'Id'", modelErrorMessage);
}
public async Task ReadAsync_InvalidArray_AddsOverflowErrorsToModelState()
{
// Arrange
var content = "[0, 23, 300]";
var formatter = new JsonInputFormatter();
var contentBytes = Encoding.UTF8.GetBytes(content);
var modelState = new ModelStateDictionary();
var httpContext = GetHttpContext(contentBytes);
var provider = new EmptyModelMetadataProvider();
var metadata = provider.GetMetadataForType(typeof(byte[]));
var context = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: modelState,
metadata: metadata);
// Act
var result = await formatter.ReadAsync(context);
// Assert
Assert.True(result.HasError);
Assert.Equal("The supplied value is invalid for Byte.", modelState["[2]"].Errors[0].ErrorMessage);
Assert.Null(modelState["[2]"].Errors[0].Exception);
}
public async Task ReadAsync_AddsModelValidationErrorsToModelState()
{
// Arrange
var content = "{name: 'Person Name', Age: 'not-an-age'}";
var formatter = new JsonInputFormatter();
var contentBytes = Encoding.UTF8.GetBytes(content);
var modelState = new ModelStateDictionary();
var httpContext = GetHttpContext(contentBytes);
var context = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: modelState,
modelType: typeof(User));
// Act
var result = await formatter.ReadAsync(context);
// Assert
Assert.True(result.HasError);
Assert.Equal(
"Could not convert string to decimal: not-an-age. Path 'Age', line 1, position 39.",
modelState["Age"].Errors[0].Exception.Message);
}
public async Task Validates_RequiredAttribute_OnRegularAndInheritedProperties(Type type)
{
// Arrange
var contentBytes = Encoding.UTF8.GetBytes("{ \"Name\" : \"Programming C#\"}");
var jsonFormatter = new JsonInputFormatter();
var actionContext = GetActionContext(contentBytes, "application/json;charset=utf-8");
var metadata = new EmptyModelMetadataProvider().GetMetadataForType(type);
var inputFormatterContext = new InputFormatterContext(actionContext, metadata.ModelType);
// Act
var obj = await jsonFormatter.ReadAsync(inputFormatterContext);
// Assert
Assert.False(actionContext.ModelState.IsValid);
Assert.Equal(1, actionContext.ModelState.Count);
var modelErrorMessage = actionContext.ModelState.Values.First().Errors[0].Exception.Message;
Assert.Contains("Required property 'Id' not found in JSON", modelErrorMessage);
}
public void Creates_SerializerSettings_ByDefault()
{
// Arrange
// Act
var jsonFormatter = new JsonInputFormatter();
// Assert
Assert.NotNull(jsonFormatter.SerializerSettings);
}
public async Task Validates_RequiredAttributeOnStructTypes()
{
// Arrange
var contentBytes = Encoding.UTF8.GetBytes("{\"Longitude\":{}}");
var jsonFormatter = new JsonInputFormatter();
var actionContext = GetActionContext(contentBytes, "application/json;charset=utf-8");
var metadata = new EmptyModelMetadataProvider().GetMetadataForType(typeof(GpsCoordinate));
var inputFormatterContext = new InputFormatterContext(actionContext, metadata.ModelType);
// Act
var obj = await jsonFormatter.ReadAsync(inputFormatterContext);
// Assert
Assert.False(actionContext.ModelState.IsValid);
Assert.Equal(2, actionContext.ModelState.Count);
var errorMessages = GetModelStateErrorMessages(actionContext.ModelState);
Assert.Equal(3, errorMessages.Count());
Assert.Contains(
errorMessages,
(errorMessage) => errorMessage.Contains("Required property 'Latitude' not found in JSON"));
Assert.Contains(
errorMessages,
(errorMessage) => errorMessage.Contains("Required property 'X' not found in JSON"));
Assert.Contains(
errorMessages,
(errorMessage) => errorMessage.Contains("Required property 'Y' not found in JSON"));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddCors(options =>
{
options.AddPolicy("AllowAllOrigins",
builder =>
{
builder.AllowCredentials();
builder.AllowAnyOrigin();
builder.AllowAnyHeader();
builder.AllowAnyMethod();
builder.Build();
});
});
services.AddEntityFramework()
.AddInMemoryDatabase()
.AddDbContext<ApplicationDbContext<ApplicationUser, Application, IdentityRole, string>>(options =>
{
options.UseInMemoryDatabase();
});
services.AddScoped<IAuthStore<ApplicationUser, Application>, AuthStore<ApplicationUser, Application, IdentityRole,
ApplicationDbContext<ApplicationUser, Application, IdentityRole, string>, string>>();
services.AddScoped<AuthManager<ApplicationUser, Application>>();
//var i = new MockUnitOfWork<string, ApplicationDbContext<ApplicationUser, Application, IdentityRole, string>>(null);
//IUnitOfWork
services.AddScoped<IUnitOfWork<string>, MockUnitOfWork<string, ApplicationDbContext<ApplicationUser, Application, IdentityRole, string>>>();
services.AddIdentity<ApplicationUser, IdentityRole>(options =>
{
options.Password = new PasswordOptions()
{
RequiredLength = 1,
RequireDigit = false,
RequireLowercase = false,
RequireUppercase = false,
RequireNonLetterOrDigit = false
};
}).AddEntityFrameworkStores<ApplicationDbContext<ApplicationUser, Application, IdentityRole, string>>().AddDefaultTokenProviders();
services.AddAuthentication();
services.AddAuthorization(options => options.AddPolicy("ElevatedRights", policy =>
policy.RequireRole("Admin", "PowerUser", "BackupAdministrator").Build()));
// Add framework services.
services.AddInstance<IConfiguration>(Configuration);
services.AddCaching();
services.AddSignalR();
services.AddMvc(options =>
{
// for CEf client
var jsonOutputFormatter = new JsonOutputFormatter();
jsonOutputFormatter.SerializerSettings.TypeNameHandling = Newtonsoft.Json.TypeNameHandling.Objects;
var jsonInputFormatter = new JsonInputFormatter();
jsonInputFormatter.SerializerSettings.TypeNameHandling = Newtonsoft.Json.TypeNameHandling.Objects;
options.OutputFormatters.Insert(0, jsonOutputFormatter);
options.InputFormatters.Insert(0, jsonInputFormatter);
});
}
public async Task Validation_DoesNotHappen_ForNonRequired_ValueTypeProperties()
{
// Arrange
var contentBytes = Encoding.UTF8.GetBytes("{\"Name\":\"Seattle\"}");
var jsonFormatter = new JsonInputFormatter();
var actionContext = GetActionContext(contentBytes, "application/json;charset=utf-8");
var metadata = new EmptyModelMetadataProvider().GetMetadataForType(typeof(Location));
var inputFormatterContext = new InputFormatterContext(actionContext, metadata.ModelType);
// Act
var obj = await jsonFormatter.ReadAsync(inputFormatterContext);
// Assert
Assert.True(actionContext.ModelState.IsValid);
var location = obj as Location;
Assert.NotNull(location);
Assert.Equal(0, location.Id);
Assert.Equal("Seattle", location.Name);
}
public async Task ReadAsync_InvalidComplexArray_AddsOverflowErrorsToModelState()
{
// Arrange
var content = "[{name: 'Name One', Age: 30}, {name: 'Name Two', Small: 300}]";
var formatter = new JsonInputFormatter();
var contentBytes = Encoding.UTF8.GetBytes(content);
var modelState = new ModelStateDictionary();
var httpContext = GetHttpContext(contentBytes);
var provider = new EmptyModelMetadataProvider();
var metadata = provider.GetMetadataForType(typeof(User[]));
var context = new InputFormatterContext(
httpContext,
modelName: "names",
modelState: modelState,
metadata: metadata);
// Act
var result = await formatter.ReadAsync(context);
// Assert
Assert.True(result.HasError);
Assert.Equal(
"Error converting value 300 to type 'System.Byte'. Path '[1].Small', line 1, position 59.",
modelState["names[1].Small"].Errors[0].Exception.Message);
}
public async Task Validation_DoesNotHappen_OnNullableValueTypeProperties()
{
// Arrange
var contentBytes = Encoding.UTF8.GetBytes("{}");
var jsonFormatter = new JsonInputFormatter();
var actionContext = GetActionContext(contentBytes, "application/json;charset=utf-8");
var metadata = new EmptyModelMetadataProvider().GetMetadataForType(typeof(Venue));
var inputFormatterContext = new InputFormatterContext(actionContext, metadata.ModelType);
// Act
var obj = await jsonFormatter.ReadAsync(inputFormatterContext);
// Assert
Assert.True(actionContext.ModelState.IsValid);
var venue = obj as Venue;
Assert.NotNull(venue);
Assert.Null(venue.Location);
Assert.Null(venue.NearByLocations);
Assert.Null(venue.Name);
}
