public void FormatFilter_ContextContainsFormat_Custom(
string format,
FormatSource place,
string contentType)
{
// Arrange
var mediaType = new StringSegment(contentType);
var mockObjects = new MockObjects(format, place);
var resultExecutingContext = mockObjects.CreateResultExecutingContext();
var resourceExecutingContext = mockObjects.CreateResourceExecutingContext(new IFilterMetadata[] { });
mockObjects.Options.FormatterMappings.SetMediaTypeMappingForFormat(
format,
MediaTypeHeaderValue.Parse(contentType));
var filter = new FormatFilter(mockObjects.OptionsManager);
// Act
filter.OnResourceExecuting(resourceExecutingContext);
filter.OnResultExecuting(resultExecutingContext);
// Assert
var objectResult = Assert.IsType <ObjectResult>(resultExecutingContext.Result);
Assert.Single(objectResult.ContentTypes);
MediaTypeAssert.Equal(mediaType, objectResult.ContentTypes[0]);
}
public async Task ExecuteAsync_ContentTypeProvidedFromResponseAndObjectResult_UsesResponseContentType()
{
// Arrange
var executor = CreateExecutor();
var httpContext = new DefaultHttpContext();
var actionContext = new ActionContext()
{
HttpContext = httpContext
};
httpContext.Request.Headers.Accept = "application/xml"; // This will not be used
httpContext.Response.ContentType = "text/plain";
var result = new ObjectResult("input");
result.Formatters.Add(new TestXmlOutputFormatter());
result.Formatters.Add(new TestJsonOutputFormatter());
result.Formatters.Add(new TestStringOutputFormatter()); // This will be chosen based on the content type
// Act
await executor.ExecuteAsync(actionContext, result);
// Assert
MediaTypeAssert.Equal("text/plain; charset=utf-8", httpContext.Response.ContentType);
}
public async Task ObjectResult_PerformsContentNegotiation_OnAllMediaRangeAcceptHeaderMediaType(
string acceptHeader,
string expectedContentType)
{
// Arrange
var options = new MvcOptions();
options.RespectBrowserAcceptHeader = true;
var executor = CreateExecutor(options: options);
var result = new ObjectResult("input");
result.Formatters.Add(new TestJsonOutputFormatter());
result.Formatters.Add(new TestXmlOutputFormatter());
var actionContext = new ActionContext()
{
HttpContext = GetHttpContext(),
};
actionContext.HttpContext.Request.Headers.Accept = acceptHeader;
// Act
await executor.ExecuteAsync(actionContext, result);
// Assert
var responseContentType = actionContext.HttpContext.Response.Headers.ContentType;
MediaTypeAssert.Equal(expectedContentType, responseContentType);
}
public void FormatFilter_ExplicitContentType_SetOnObjectResult_TakesPrecedence()
{
// Arrange
var mediaType = new StringSegment("application/foo");
var mockObjects = new MockObjects("json", FormatSource.QueryData);
var httpContext = new Mock <HttpContext>();
httpContext.Setup(c => c.Response).Returns(new Mock <HttpResponse>().Object);
httpContext.Setup(c => c.Request.Query["format"]).Returns("json");
var actionContext = new ActionContext(httpContext.Object, new RouteData(), new ActionDescriptor());
var objectResult = new ObjectResult("Hello!");
objectResult.ContentTypes.Add(new MediaTypeHeaderValue("application/foo"));
var resultExecutingContext = new ResultExecutingContext(
actionContext,
new IFilterMetadata[] { },
objectResult,
controller: new object());
var resourceExecutingContext = new ResourceExecutingContext(
actionContext,
new IFilterMetadata[] { });
var filter = new FormatFilter(mockObjects.OptionsManager);
// Act
filter.OnResourceExecuting(resourceExecutingContext);
filter.OnResultExecuting(resultExecutingContext);
// Assert
var result = Assert.IsType <ObjectResult>(resultExecutingContext.Result);
Assert.Equal(1, result.ContentTypes.Count);
MediaTypeAssert.Equal(mediaType, result.ContentTypes[0]);
}
public async Task ExecuteAsync_ForProblemDetailsValue_UsesProblemDetailsContentType()
{
// Arrange
var executor = CreateExecutor();
var httpContext = new DefaultHttpContext();
var actionContext = new ActionContext()
{
HttpContext = httpContext
};
httpContext.Response.ContentType = "application/json"; // This will not be used
var result = new ObjectResult(new ProblemDetails());
result.Formatters.Add(new TestXmlOutputFormatter()); // This will be chosen based on the problem details content type
result.Formatters.Add(new TestJsonOutputFormatter());
result.Formatters.Add(new TestStringOutputFormatter());
// Act
await executor.ExecuteAsync(actionContext, result);
// Assert
MediaTypeAssert.Equal("application/problem+xml; charset=utf-8", httpContext.Response.ContentType);
}
public async Task ExecuteAsync_ForProblemDetailsValue_UsesProblemDetailsXMLContentType_BasedOnAcceptHeader()
{
// Arrange
var executor = CreateExecutor();
var httpContext = new DefaultHttpContext();
var actionContext = new ActionContext()
{
HttpContext = httpContext
};
httpContext.Request.Headers.Accept = "application/xml"; // This will not be used
var result = new ObjectResult(new ProblemDetails())
{
ContentTypes = { "text/plain" }, // This will not be used
};
result.Formatters.Add(new TestJsonOutputFormatter());
result.Formatters.Add(new TestXmlOutputFormatter()); // This will be chosen based on the Accept Headers "application/xml"
result.Formatters.Add(new TestStringOutputFormatter());
// Act
await executor.ExecuteAsync(actionContext, result);
// Assert
MediaTypeAssert.Equal("application/problem+xml; charset=utf-8", httpContext.Response.ContentType);
}
public void FormatFilter_ContextContainsFormat_DefaultFormat(
string format,
FormatSource place,
string contentType)
{
// Arrange
var mediaType = new StringSegment("application/json");
var mockObjects = new MockObjects(format, place);
var resultExecutingContext = mockObjects.CreateResultExecutingContext();
var resourceExecutingContext = mockObjects.CreateResourceExecutingContext(new IFilterMetadata[] { });
var filter = new FormatFilter(mockObjects.OptionsManager);
// Act
filter.OnResourceExecuting(resourceExecutingContext);
// Assert
Assert.Null(resourceExecutingContext.Result);
// Act
filter.OnResultExecuting(resultExecutingContext);
// Assert
var objectResult = Assert.IsType <ObjectResult>(resultExecutingContext.Result);
Assert.Single(objectResult.ContentTypes);
MediaTypeAssert.Equal(mediaType, objectResult.ContentTypes[0]);
}
public void SelectFormatter_WithNoProvidedContentType_DoesConneg()
{
// Arrange
var executor = CreateExecutor();
var formatters = new List <IOutputFormatter>
{
new TestXmlOutputFormatter(),
new TestJsonOutputFormatter(), // This will be chosen based on the accept header
};
var context = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
objectType: null,
@object: null);
context.HttpContext.Request.Headers[HeaderNames.Accept] = "application/json";
// Act
var formatter = executor.SelectFormatter(
context,
new MediaTypeCollection {
"application/json"
},
formatters);
// Assert
Assert.Same(formatters[1], formatter);
MediaTypeAssert.Equal("application/json", context.ContentType);
}
public void ProducesResponseTypeAttribute_SetsContentType()
{
// Arrange
var mediaType1 = new StringSegment("application/json");
var mediaType2 = new StringSegment("text/json;charset=utf-8");
var producesContentAttribute = new ProducesResponseTypeAttribute(typeof(void), StatusCodes.Status200OK, "application/json", "text/json;charset=utf-8");
// Assert
Assert.Equal(2, producesContentAttribute.ContentTypes.Count);
MediaTypeAssert.Equal(mediaType1, producesContentAttribute.ContentTypes[0]);
MediaTypeAssert.Equal(mediaType2, producesContentAttribute.ContentTypes[1]);
}
public void FormatterMappings_SetFormatMapping_DiffSetGetFormat(string setFormat, string contentType, string getFormat)
{
// Arrange
var options = new FormatterMappings();
options.SetMediaTypeMappingForFormat(setFormat, MediaTypeHeaderValue.Parse(contentType));
// Act
var returnMediaType = options.GetMediaTypeMappingForFormat(getFormat);
// Assert
MediaTypeAssert.Equal(contentType, returnMediaType);
}
public void Constructor_SetsContentTypeAndParameters()
{
// Arrange
var path = Path.GetFullPath("helllo.txt");
var contentType = "text/plain; charset=us-ascii; p1=p1-value";
var expectedMediaType = contentType;
// Act
var result = new VirtualFileResult(path, contentType);
// Assert
Assert.Equal(path, result.FileName);
MediaTypeAssert.Equal(expectedMediaType, result.ContentType);
}
public void FormatFilter_ContextContainsFormat_InRouteAndQueryData()
{
// If the format is present in both route and query data, the one in route data wins
// Arrange
var mediaType = new StringSegment("application/json");
var mockObjects = new MockObjects("json", FormatSource.RouteData);
var httpContext = new Mock <HttpContext>();
httpContext.Setup(c => c.Response).Returns(new Mock <HttpResponse>().Object);
// Query contains xml
httpContext.Setup(c => c.Request.Query.ContainsKey("format")).Returns(true);
httpContext.Setup(c => c.Request.Query["format"]).Returns("xml");
// Routedata contains json
var data = new RouteData();
data.Values.Add("format", "json");
var ac = new ActionContext(httpContext.Object, data, new ActionDescriptor());
var resultExecutingContext = new ResultExecutingContext(
ac,
new IFilterMetadata[] { },
new ObjectResult("Hello!"),
controller: new object());
var resourceExecutingContext = new ResourceExecutingContext(
ac,
new IFilterMetadata[] { },
new List <IValueProviderFactory>());
var filter = new FormatFilter(mockObjects.OptionsManager);
// Act
filter.OnResourceExecuting(resourceExecutingContext);
filter.OnResultExecuting(resultExecutingContext);
// Assert
var objectResult = Assert.IsType <ObjectResult>(resultExecutingContext.Result);
Assert.Single(objectResult.ContentTypes);
MediaTypeAssert.Equal(mediaType, objectResult.ContentTypes[0]);
}
public async Task ViewComponentResult_SetsContentTypeHeader(
string contentType,
string expectedContentType)
{
// Arrange
var methodInfo = typeof(TextViewComponent).GetMethod(nameof(TextViewComponent.Invoke));
var descriptor = new ViewComponentDescriptor()
{
FullName = "Full.Name.Text",
ShortName = "Text",
TypeInfo = typeof(TextViewComponent).GetTypeInfo(),
MethodInfo = methodInfo,
Parameters = methodInfo.GetParameters(),
};
var actionContext = CreateActionContext(descriptor);
var contentTypeBeforeViewResultExecution = contentType?.ToString();
var viewComponentResult = new ViewComponentResult()
{
Arguments = new { name = "World!" },
ViewComponentName = "Text",
ContentType = contentType,
TempData = _tempDataDictionary,
};
// Act
await viewComponentResult.ExecuteResultAsync(actionContext);
// Assert
var resultContentType = actionContext.HttpContext.Response.ContentType;
MediaTypeAssert.Equal(expectedContentType, resultContentType);
// Check if the original instance provided by the user has not changed.
// Since we do not have access to the new instance created within the view executor,
// check if at least the content is the same.
var contentTypeAfterViewResultExecution = contentType?.ToString();
MediaTypeAssert.Equal(contentTypeBeforeViewResultExecution, contentTypeAfterViewResultExecution);
}
public void ProducesAttribute_SetsContentType()
{
// Arrange
var mediaType1 = new StringSegment("application/json");
var mediaType2 = new StringSegment("text/json;charset=utf-8");
var producesContentAttribute = new ProducesAttribute("application/json", "text/json;charset=utf-8");
var resultExecutingContext = CreateResultExecutingContext(new IFilterMetadata[] { producesContentAttribute });
var next = new ResultExecutionDelegate(
() => Task.FromResult(CreateResultExecutedContext(resultExecutingContext)));
// Act
producesContentAttribute.OnResultExecuting(resultExecutingContext);
// Assert
var objectResult = resultExecutingContext.Result as ObjectResult;
Assert.Equal(2, objectResult.ContentTypes.Count);
MediaTypeAssert.Equal(mediaType1, objectResult.ContentTypes[0]);
MediaTypeAssert.Equal(mediaType2, objectResult.ContentTypes[1]);
}
public async Task ContentResult_ExecuteResultAsync_Response_NullContent_SetsContentTypeAndEncoding()
{
// Arrange
var contentResult = new ContentResult
{
Content = null,
ContentType = new MediaTypeHeaderValue("text/plain")
{
Encoding = Encoding.Unicode
}.ToString()
};
var httpContext = GetHttpContext();
var actionContext = GetActionContext(httpContext);
// Act
await contentResult.ExecuteResultAsync(actionContext);
// Assert
MediaTypeAssert.Equal("text/plain; charset=utf-16", httpContext.Response.ContentType);
}
public async Task ExecuteAsync_SetsContentTypeAndEncoding(
MediaTypeHeaderValue contentType,
string responseContentType,
string expectedContentType)
{
// Arrange
var view = CreateView(async(v) =>
{
await v.Writer.WriteAsync("abcd");
});
var context = new DefaultHttpContext();
var memoryStream = new MemoryStream();
context.Response.Body = memoryStream;
context.Response.ContentType = responseContentType;
var actionContext = new ActionContext(
context,
new RouteData(),
new ActionDescriptor());
var viewData = new ViewDataDictionary(new EmptyModelMetadataProvider());
var viewExecutor = CreateViewExecutor();
// Act
await viewExecutor.ExecuteAsync(
actionContext,
view,
viewData,
Mock.Of <ITempDataDictionary>(),
contentType?.ToString(),
statusCode : null);
// Assert
MediaTypeAssert.Equal(expectedContentType, context.Response.ContentType);
Assert.Equal("abcd", Encoding.UTF8.GetString(memoryStream.ToArray()));
}
public async Task ExecuteAsync_NoContentTypeProvidedForProblemDetails_UsesDefaultContentTypes()
{
// Arrange
var executor = CreateExecutor();
var httpContext = new DefaultHttpContext();
var actionContext = new ActionContext()
{
HttpContext = httpContext
};
var result = new ObjectResult(new ProblemDetails());
result.Formatters.Add(new TestXmlOutputFormatter()); // This will be chosen based on the implicitly added content type
result.Formatters.Add(new TestJsonOutputFormatter());
result.Formatters.Add(new TestStringOutputFormatter());
// Act
await executor.ExecuteAsync(actionContext, result);
// Assert
MediaTypeAssert.Equal("application/problem+xml; charset=utf-8", httpContext.Response.ContentType);
}
