private async Task WriteResponseBodyImplAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)
{
var response = context.HttpContext.Response;
FieldsParserResult fieldsParserResult = default;
if (!this.ShouldBypassPartialResponse(context.HttpContext))
{
fieldsParserResult = this.fieldsParser.Parse(context.HttpContext.Request);
if (fieldsParserResult.HasError && !this.options.IgnoreParseErrors)
{
response.StatusCode = 400;
return;
}
}
using (var writer = context.WriterFactory(response.Body, selectedEncoding))
{
this.WriteObject(writer, context.Object, fieldsParserResult);
// Perf: call FlushAsync to call WriteAsync on the stream with any content left in the TextWriter's
// buffers. This is better than just letting dispose handle it (which would result in a synchronous
// write).
await writer.FlushAsync();
}
}
public async Task TheWriteResponseBodyAsyncMethodShouldReturnStatusCode400IfFieldsMalformed()
{
// Arrange
Mock.Get(this.httpResponse)
.SetupGet(httpResponse => httpResponse.StatusCode)
.Returns(200);
Mock.Get(this.fieldsParser)
.Setup(fieldsParser => fieldsParser.Parse(this.httpRequest))
.Returns(FieldsParserResult.Failed());
this.mvcPartialJsonOptions.IgnoreParseErrors = false;
this.mvcPartialJsonOptions.IgnoreCase = false;
var writeContext = this.CreateWriteContext(new { });
// Act
await this.formatter.WriteResponseBodyAsync(writeContext, Encoding.UTF8);
// Assert
Mock.Get(this.httpResponse)
.VerifySet(httpResponse => httpResponse.StatusCode = 400);
Assert.Equal(0, this.body.Length);
}
public async Task TheWriteResponseBodyAsyncMethodShouldNotReturnStatusCode400IfFieldsMalformedButParseErrorsIgnored()
{
// Arrange
Mock.Get(this.httpResponse)
.SetupGet(httpResponse => httpResponse.StatusCode)
.Returns(200);
Mock.Get(this.fieldsParser)
.Setup(fieldsParser => fieldsParser.Parse(this.httpRequest))
.Returns(FieldsParserResult.Failed());
this.mvcPartialJsonOptions.IgnoreParseErrors = true;
this.mvcPartialJsonOptions.IgnoreCase = false;
var writeContext = this.CreateWriteContext(new { foo = "bar" });
// Act
await this.formatter.WriteResponseBodyAsync(writeContext, Encoding.UTF8);
// Assert
Mock.Get(this.httpResponse)
.VerifySet(httpResponse => httpResponse.StatusCode = 400, Times.Never);
Assert.Equal("{\"foo\":\"bar\"}", this.body.ToString());
}
public void TheNoValueMethodShouldSetIsFieldsSetToFalse()
{
// Act
var result = FieldsParserResult.NoValue();
// Assert
Assert.False(result.IsFieldsSet);
}
public void TheNoValueMethodShouldSetHasErrorToFalse()
{
// Act
var result = FieldsParserResult.NoValue();
// Assert
Assert.False(result.HasError);
}
public void TheFailedMethodShouldSetHasErrorToTrue()
{
// Act
var result = FieldsParserResult.Failed();
// Assert
Assert.True(result.HasError);
}
public void TheSuccessMethodShouldSetIsFieldsSetToTrue()
{
// Arrange
Fields.TryParse("foo", out var fields);
// Act
var result = FieldsParserResult.Success(fields);
// Assert
Assert.True(result.IsFieldsSet);
}
public void TheSuccessMethodShouldSetHasErrorToFalse()
{
// Arrange
Fields.TryParse("foo", out var fields);
// Act
var result = FieldsParserResult.Success(fields);
// Assert
Assert.False(result.HasError);
}
public void TheSuccessMethodShouldSetFields()
{
// Arrange
Fields.TryParse("foo", out var fields);
// Act
var result = FieldsParserResult.Success(fields);
// Assert
var field = result.Fields.Values.First();
var part = field.Parts.First();
Assert.Equal("foo", part.ToString());
}
public async Task TheExecuteAsyncMethodShouldNotApplyFieldsIfNotSupplied()
{
// Arrange
Mock.Get(this.fieldsParser)
.Setup(fieldsParser => fieldsParser.Parse(this.httpRequest))
.Returns(FieldsParserResult.NoValue());
var partialJsonResult = new PartialJsonResult(new { foo = "bar" }, new JsonSerializerSettings());
// Act
await this.executor.ExecuteAsync(this.actionContext, partialJsonResult);
// Assert
Assert.Equal("{\"foo\":\"bar\"}", this.body.ToString());
}
private async Task WriteResponseBodyImplAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)
{
var response = context.HttpContext.Response;
FieldsParserResult fieldsParserResult = default;
if (!this.ShouldBypassPartialResponse(context.HttpContext))
{
fieldsParserResult = this.fieldsParser.Parse(context.HttpContext.Request);
if (fieldsParserResult.HasError && !this.options.IgnoreParseErrors)
{
response.StatusCode = 400;
return;
}
}
var responseStream = response.Body;
FileBufferingWriteStream fileBufferingWriteStream = null;
if (!this.mvcOptions.SuppressOutputFormatterBuffering)
{
fileBufferingWriteStream = new FileBufferingWriteStream();
responseStream = fileBufferingWriteStream;
}
try
{
await using (var writer = context.WriterFactory(responseStream, selectedEncoding))
{
this.WriteObject(writer, context.Object, fieldsParserResult);
}
if (fileBufferingWriteStream != null)
{
response.ContentLength = fileBufferingWriteStream.Length;
await fileBufferingWriteStream.DrainBufferAsync(response.Body);
}
}
finally
{
if (fileBufferingWriteStream != null)
{
await fileBufferingWriteStream.DisposeAsync();
}
}
}
private void WriteObject(TextWriter writer, object value, FieldsParserResult fieldsParserResult)
{
using (var jsonWriter = this.CreateJsonWriter(writer))
{
var jsonSerializer = this.CreateJsonSerializer();
if (fieldsParserResult.IsFieldsSet && !fieldsParserResult.HasError)
{
jsonSerializer.Serialize(jsonWriter, value, path => fieldsParserResult.Fields.Matches(path, this.options.IgnoreCase));
}
else
{
jsonSerializer.Serialize(jsonWriter, value);
}
}
}
public async Task TheExecuteAsyncMethodShouldReturnStatusCode400IfFieldsMalformed()
{
// Arrange
Mock.Get(this.fieldsParser)
.Setup(fieldsParser => fieldsParser.Parse(this.httpRequest))
.Returns(FieldsParserResult.Failed());
var partialJsonResult = new PartialJsonResult(new { });
// Act
await this.executor.ExecuteAsync(this.actionContext, partialJsonResult);
// Assert
Mock.Get(this.httpResponse)
.VerifySet(httpResponse => httpResponse.StatusCode = 400);
Assert.Equal(0, this.body.Length);
}
public async Task TheWriteResponseBodyAsyncMethodShouldNotApplyFieldsIfNotSupplied()
{
// Arrange
Mock.Get(this.httpResponse)
.SetupGet(httpResponse => httpResponse.StatusCode)
.Returns(200);
Mock.Get(this.fieldsParser)
.Setup(fieldsParser => fieldsParser.Parse(this.httpRequest))
.Returns(FieldsParserResult.NoValue());
var writeContext = this.CreateWriteContext(new { foo = "bar" });
// Act
await this.formatter.WriteResponseBodyAsync(writeContext, Encoding.UTF8);
// Assert
Assert.Equal("{\"foo\":\"bar\"}", this.body.ToString());
}
public async Task TheExecuteAsyncMethodShouldNotIgnoreCase()
{
// Arrange
Fields.TryParse("FOO", out var fields);
Mock.Get(this.fieldsParser)
.Setup(fieldsParser => fieldsParser.Parse(this.httpRequest))
.Returns(FieldsParserResult.Success(fields));
this.mvcPartialJsonOptions.IgnoreCase = false;
var partialJsonResult = new PartialJsonResult(new { foo = "bar", baz = "qux" }, new JsonSerializerSettings());
// Act
await this.executor.ExecuteAsync(this.actionContext, partialJsonResult);
// Assert
Assert.Equal("{}", this.body.ToString());
}
public async Task TheExecuteAsyncMethodShouldNotReturnStatusCode400IfFieldsMalformedButParseErrorsIgnored()
{
// Arrange
Mock.Get(this.fieldsParser)
.Setup(fieldsParser => fieldsParser.Parse(this.httpRequest))
.Returns(FieldsParserResult.Failed());
var partialJsonResult = new PartialJsonResult(new { foo = "bar" });
this.mvcPartialJsonOptions.IgnoreParseErrors = true;
// Act
await this.executor.ExecuteAsync(this.actionContext, partialJsonResult);
// Assert
Mock.Get(this.httpResponse)
.VerifySet(httpResponse => httpResponse.StatusCode = 400, Times.Never);
Assert.Equal("{\"foo\":\"bar\"}", this.body.ToString());
}
public async Task TheWriteResponseBodyAsyncMethodShouldBypassPartialResponseIfStatusCodeIsNot200()
{
// Arrange
Mock.Get(this.httpResponse)
.SetupGet(httpResponse => httpResponse.StatusCode)
.Returns(500);
Fields.TryParse(string.Empty, out var fields);
Mock.Get(this.fieldsParser)
.Setup(fieldsParser => fieldsParser.Parse(this.httpRequest))
.Returns(FieldsParserResult.Success(fields));
var writeContext = this.CreateWriteContext(new { foo = "bar" });
// Act
await this.formatter.WriteResponseBodyAsync(writeContext, Encoding.UTF8);
// Assert
Assert.Equal("{\"foo\":\"bar\"}", this.body.ToString());
}
public async Task TheWriteResponseBodyAsyncMethodShouldNotIgnoreCase()
{
// Arrange
Mock.Get(this.httpResponse)
.SetupGet(httpResponse => httpResponse.StatusCode)
.Returns(200);
Fields.TryParse("FOO", out var fields);
Mock.Get(this.fieldsParser)
.Setup(fieldsParser => fieldsParser.Parse(this.httpRequest))
.Returns(FieldsParserResult.Success(fields));
this.mvcPartialJsonOptions.IgnoreCase = false;
var writeContext = this.CreateWriteContext(new { foo = "bar" });
// Act
await this.formatter.WriteResponseBodyAsync(writeContext, Encoding.UTF8);
// Assert
Assert.Equal("{}", this.body.ToString());
}
