public void SelectResponseCharacterEncoding_SelectsEncoding(
string acceptCharsetHeaders,
string[] supportedEncodings,
string expectedEncoding)
{
// Arrange
var httpContext = new Mock<HttpContext>();
var httpRequest = new DefaultHttpContext().Request;
httpRequest.Headers[HeaderNames.AcceptCharset] = acceptCharsetHeaders;
httpRequest.Headers[HeaderNames.Accept] = "application/acceptCharset";
httpContext.SetupGet(o => o.Request).Returns(httpRequest);
var formatter = new TestOutputFormatter();
foreach (string supportedEncoding in supportedEncodings)
{
formatter.SupportedEncodings.Add(Encoding.GetEncoding(supportedEncoding));
}
var context = new OutputFormatterWriteContext(
httpContext.Object,
new TestHttpResponseStreamWriterFactory().CreateWriter,
typeof(string),
"someValue")
{
ContentType = new StringSegment(httpRequest.Headers[HeaderNames.Accept]),
};
// Act
var actualEncoding = formatter.SelectCharacterEncoding(context);
// Assert
Assert.Equal(Encoding.GetEncoding(expectedEncoding), actualEncoding);
}
public void SelectResponseCharacterEncoding_SelectsEncoding(string acceptCharsetHeaders,
string requestEncoding,
string[] supportedEncodings,
string expectedEncoding)
{
// Arrange
var mockHttpContext = new Mock<HttpContext>();
mockHttpContext.SetupGet(o => o.Request.AcceptCharset)
.Returns(acceptCharsetHeaders);
mockHttpContext.SetupGet(o => o.Request.ContentType)
.Returns("application/acceptCharset;charset=" + requestEncoding);
var actionContext = new ActionContext(mockHttpContext.Object, new RouteData(), new ActionDescriptor());
var formatter = new TestOutputFormatter();
foreach (string supportedEncoding in supportedEncodings)
{
formatter.SupportedEncodings.Add(Encoding.GetEncoding(supportedEncoding));
}
var formatterContext = new OutputFormatterContext()
{
Object = "someValue",
ActionContext = actionContext,
DeclaredType = typeof(string)
};
// Act
var actualEncoding = formatter.SelectCharacterEncoding(formatterContext);
// Assert
Assert.Equal(Encoding.GetEncoding(expectedEncoding), actualEncoding);
}
public void WriteResponseContentHeaders_NoSupportedEncodings_NoEncodingIsSet()
{
// Arrange
var formatter = new TestOutputFormatter();
var testContentType = MediaTypeHeaderValue.Parse("text/json");
formatter.SupportedEncodings.Clear();
formatter.SupportedMediaTypes.Clear();
formatter.SupportedMediaTypes.Add(testContentType);
var context = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
objectType: null,
@object: null)
{
ContentType = testContentType,
};
// Act
formatter.WriteResponseHeaders(context);
// Assert
Assert.Null(context.ContentType.Encoding);
Assert.Equal(testContentType, context.ContentType);
// If we had set an encoding, it would be part of the content type header
Assert.Equal(testContentType, context.HttpContext.Response.GetTypedHeaders().ContentType);
}
public void WriteResponseContentHeaders_NoSupportedEncodings_NoEncodingIsSet()
{
// Arrange
var formatter = new TestOutputFormatter();
var testContentType = MediaTypeHeaderValue.Parse("text/json");
formatter.SupportedEncodings.Clear();
formatter.SupportedMediaTypes.Clear();
formatter.SupportedMediaTypes.Add(testContentType);
var formatterContext = new OutputFormatterContext()
{
HttpContext = new DefaultHttpContext(),
};
// Act
formatter.WriteResponseHeaders(formatterContext);
// Assert
Assert.Null(formatterContext.SelectedEncoding);
Assert.Equal(testContentType, formatterContext.SelectedContentType);
// If we had set an encoding, it would be part of the content type header
Assert.Equal(testContentType, formatterContext.HttpContext.Response.GetTypedHeaders().ContentType);
}
public void SelectResponseCharacterEncoding_SelectsEncoding(string acceptCharsetHeaders,
string requestEncoding,
string[] supportedEncodings,
string expectedEncoding)
{
// Arrange
var mockHttpContext = new Mock<HttpContext>();
var httpRequest = new DefaultHttpContext().Request;
httpRequest.Headers["Accept-Charset"] = acceptCharsetHeaders;
httpRequest.ContentType = "application/acceptCharset;charset=" + requestEncoding;
mockHttpContext.SetupGet(o => o.Request).Returns(httpRequest);
var formatter = new TestOutputFormatter();
foreach (string supportedEncoding in supportedEncodings)
{
formatter.SupportedEncodings.Add(Encoding.GetEncoding(supportedEncoding));
}
var formatterContext = new OutputFormatterContext()
{
Object = "someValue",
HttpContext = mockHttpContext.Object,
DeclaredType = typeof(string)
};
// Act
var actualEncoding = formatter.SelectCharacterEncoding(formatterContext);
// Assert
Assert.Equal(Encoding.GetEncoding(expectedEncoding), actualEncoding);
}
public void ConstructorSets_OutputFormatterInsnaceAndType()
{
// Arrange
var testFormatter = new TestOutputFormatter();
// Act
var descriptor = new OutputFormatterDescriptor(testFormatter);
// Assert
Assert.Same(testFormatter, descriptor.Instance);
Assert.Equal(testFormatter.GetType(), descriptor.OptionType);
}
public void GetSupportedContentTypes_ReturnsAllContentTypes_ReturnsNullWithNoSupportedContentTypes()
{
// Arrange
var formatter = new TestOutputFormatter();
// Intentionally empty
formatter.SupportedMediaTypes.Clear();
// Act
var contentTypes = formatter.GetSupportedContentTypes(
typeof(int),
typeof(int),
contentType: null);
// Assert
Assert.Null(contentTypes);
}
public void GetSupportedContentTypes_ReturnsAllContentTypes_WithContentTypeNull()
{
// Arrange
var formatter = new TestOutputFormatter();
formatter.SupportedMediaTypes.Clear();
formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/json"));
formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/xml"));
// Act
var contentTypes = formatter.GetSupportedContentTypes(typeof(int), typeof(int), contentType: null);
// Assert
Assert.Equal(2, contentTypes.Count);
Assert.Single(contentTypes, ct => ct.ToString() == "application/json");
Assert.Single(contentTypes, ct => ct.ToString() == "application/xml");
}
public void CanWriteResult_ForNullContentType_UsesFirstEntryInSupportedContentTypes()
{
// Arrange
var context = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
objectType: null,
@object: null);
var formatter = new TestOutputFormatter();
// Act
var result = formatter.CanWriteResult(context);
// Assert
Assert.True(result);
Assert.Equal(formatter.SupportedMediaTypes[0].ToString(), context.ContentType.ToString());
}
public void GetSupportedContentTypes_ReturnsAllContentTypes_WithContentTypeNull()
{
// Arrange
var formatter = new TestOutputFormatter();
formatter.SupportedMediaTypes.Clear();
formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/json"));
formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/xml"));
// Act
var contentTypes = formatter.GetSupportedContentTypes(
contentType: null,
objectType: typeof(string));
// Assert
Assert.Equal(2, contentTypes.Count);
Assert.Single(contentTypes, ct => ct.ToString() == "application/json");
Assert.Single(contentTypes, ct => ct.ToString() == "application/xml");
}
public void GetSupportedContentTypes_ReturnsMatchingContentTypes_NoMatches()
{
// Arrange
var formatter = new TestOutputFormatter();
formatter.SupportedMediaTypes.Clear();
formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/json"));
formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("text/xml"));
// Act
var contentTypes = formatter.GetSupportedContentTypes(
typeof(int),
typeof(int),
contentType: MediaTypeHeaderValue.Parse("application/xml"));
// Assert
Assert.Null(contentTypes);
}
public void CanWriteResult_ForNullContentType_UsesFirstEntryInSupportedContentTypes()
{
// Arrange
var context = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
objectType: null,
@object: null);
var formatter = new TestOutputFormatter();
// Act
var result = formatter.CanWriteResult(context);
// Assert
Assert.True(result);
Assert.Equal(formatter.SupportedMediaTypes[0].ToString(), context.ContentType.ToString());
}
public void WriteResponseContentHeaders_FormatterWithNoEncoding_Throws()
{
// Arrange
var testFormatter = new TestOutputFormatter();
var testContentType = MediaTypeHeaderValue.Parse("text/invalid");
var formatterContext = new OutputFormatterContext();
var mockHttpContext = new Mock<HttpContext>();
var httpRequest = new DefaultHttpContext().Request;
mockHttpContext.SetupGet(o => o.Request).Returns(httpRequest);
formatterContext.HttpContext = mockHttpContext.Object;
// Act & Assert
var ex = Assert.Throws<InvalidOperationException>(
() => testFormatter.WriteResponseHeaders(formatterContext));
Assert.Equal("No encoding found for output formatter " +
"'Microsoft.AspNet.Mvc.Test.OutputFormatterTests+TestOutputFormatter'." +
" There must be at least one supported encoding registered in order for the" +
" output formatter to write content.", ex.Message);
}
public void GetSupportedContentTypes_ReturnsMoreSpecificMatchingContentTypes_WithContentType()
{
// Arrange
var formatter = new TestOutputFormatter();
formatter.SupportedMediaTypes.Clear();
formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/json"));
formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("text/xml"));
// Act
var contentTypes = formatter.GetSupportedContentTypes(
"application/*",
typeof(int));
// Assert
var contentType = Assert.Single(contentTypes);
Assert.Equal("application/json", contentType.ToString());
}
public void WriteResponseContentHeaders_FormatterWithNoEncoding_Throws()
{
// Arrange
var testFormatter = new TestOutputFormatter();
var testContentType = MediaTypeHeaderValue.Parse("text/invalid");
var formatterContext = new OutputFormatterContext();
var mockHttpContext = new Mock <HttpContext>();
var httpRequest = new DefaultHttpContext().Request;
mockHttpContext.SetupGet(o => o.Request).Returns(httpRequest);
formatterContext.HttpContext = mockHttpContext.Object;
// Act & Assert
var ex = Assert.Throws <InvalidOperationException>(
() => testFormatter.WriteResponseHeaders(formatterContext));
Assert.Equal("No encoding found for output formatter " +
"'Microsoft.AspNet.Mvc.Test.OutputFormatterTests+TestOutputFormatter'." +
" There must be at least one supported encoding registered in order for the" +
" output formatter to write content.", ex.Message);
}
public void WriteResponse_GetMediaTypeWithCharsetReplacesCharset_IfDifferentThanEncoding()
{
// Arrange
var formatter = new TestOutputFormatter();
var formatterContext = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
objectType: null,
@object: null)
{
ContentType = new StringSegment("application/json; charset=utf-7"),
};
formatter.SupportedMediaTypes.Add("application/json");
formatter.SupportedEncodings.Add(Encoding.UTF8);
// Act
formatter.WriteAsync(formatterContext);
// Assert
Assert.Equal(new StringSegment("application/json; charset=utf-8"), formatterContext.ContentType);
}
public void WriteResponse_GetMediaTypeWithCharsetReturnsSameString_IfCharsetEqualToEncoding()
{
// Arrange
var formatter = new TestOutputFormatter();
var contentType = "application/json; charset=utf-16";
var formatterContext = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
objectType: null,
@object: null)
{
ContentType = new StringSegment(contentType),
};
formatter.SupportedMediaTypes.Add("application/json");
formatter.SupportedEncodings.Add(Encoding.Unicode);
// Act
formatter.WriteAsync(formatterContext);
// Assert
Assert.Same(contentType, formatterContext.ContentType.Buffer);
}
public void GetSupportedContentTypes_ReturnsAllContentTypes_ReturnsNullWithNoSupportedContentTypes()
{
// Arrange
var formatter = new TestOutputFormatter();
// Intentionally empty
formatter.SupportedMediaTypes.Clear();
// Act
var contentTypes = formatter.GetSupportedContentTypes(
typeof(int),
typeof(int),
contentType: null);
// Assert
Assert.Null(contentTypes);
}
public void GetSupportedContentTypes_ReturnsMatchingContentTypes_NoMatches()
{
// Arrange
var formatter = new TestOutputFormatter();
formatter.SupportedMediaTypes.Clear();
formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/json"));
formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("text/xml"));
// Act
var contentTypes = formatter.GetSupportedContentTypes(
typeof(int),
typeof(int),
contentType: MediaTypeHeaderValue.Parse("application/xml"));
// Assert
Assert.Null(contentTypes);
}
public void GetSupportedContentTypes_ReturnsMatchingContentTypes_WithContentType()
{
// Arrange
var formatter = new TestOutputFormatter();
formatter.SupportedMediaTypes.Clear();
formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/json"));
formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("text/xml"));
// Act
var contentTypes = formatter.GetSupportedContentTypes(
typeof(int),
typeof(int),
contentType: MediaTypeHeaderValue.Parse("application/*"));
// Assert
var contentType = Assert.Single(contentTypes);
Assert.Equal("application/json", contentType.ToString());
}
public void CanWriteResult_ForNullContentType_UsesFirstEntryInSupportedContentTypes()
{
// Arrange
var context = new OutputFormatterContext();
var formatter = new TestOutputFormatter();
// Act
var result = formatter.CanWriteResult(context, null);
// Assert
Assert.True(result);
Assert.Equal(formatter.SupportedMediaTypes[0].ToString(), context.SelectedContentType.ToString());
}
public void WriteResponse_GetMediaTypeWithCharsetReturnsMediaTypeFromCache_IfEncodingIsUtf8()
{
// Arrange
var formatter = new TestOutputFormatter();
var formatterContext = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
objectType: null,
@object: null)
{
ContentType = new StringSegment("application/json"),
};
formatter.SupportedMediaTypes.Add("application/json");
formatter.SupportedEncodings.Add(Encoding.UTF8);
// Act
formatter.WriteAsync(formatterContext);
var firstContentType = formatterContext.ContentType;
formatterContext.ContentType = new StringSegment("application/json");
formatter.WriteAsync(formatterContext);
var secondContentType = formatterContext.ContentType;
// Assert
Assert.Same(firstContentType.Buffer, secondContentType.Buffer);
}
public void CanWrite_ThrowsInvalidOperationException_IfMediaTypesListIsEmpty()
{
// Arrange
var formatter = new TestOutputFormatter();
formatter.SupportedMediaTypes.Clear();
var context = new OutputFormatterWriteContext(
new DefaultHttpContext(),
(s, e) => new StreamWriter(s, e),
typeof(object),
new object());
// Act & Assert
Assert.Throws<InvalidOperationException>(() => formatter.CanWriteResult(context));
}
public void WriteResponse_GetMediaTypeWithCharsetReturnsSameString_IfCharsetEqualToEncoding()
{
// Arrange
var formatter = new TestOutputFormatter();
var contentType = "application/json; charset=utf-16";
var formatterContext = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
objectType: null,
@object: null)
{
ContentType = new StringSegment(contentType),
};
formatter.SupportedMediaTypes.Add("application/json");
formatter.SupportedEncodings.Add(Encoding.Unicode);
// Act
formatter.WriteAsync(formatterContext);
// Assert
Assert.Same(contentType, formatterContext.ContentType.Buffer);
}
public void WriteResponse_GetMediaTypeWithCharsetReplacesCharset_IfDifferentThanEncoding()
{
// Arrange
var formatter = new TestOutputFormatter();
var formatterContext = new OutputFormatterWriteContext(
new DefaultHttpContext(),
new TestHttpResponseStreamWriterFactory().CreateWriter,
objectType: null,
@object: null)
{
ContentType = new StringSegment("application/json; charset=utf-7"),
};
formatter.SupportedMediaTypes.Add("application/json");
formatter.SupportedEncodings.Add(Encoding.UTF8);
// Act
formatter.WriteAsync(formatterContext);
// Assert
Assert.Equal(new StringSegment("application/json; charset=utf-8"), formatterContext.ContentType);
}
public void GetSupportedContentTypes_ThrowsInvalidOperationException_IfMediaTypesListIsEmpty()
{
// Arrange
var formatter = new TestOutputFormatter();
formatter.SupportedMediaTypes.Clear();
// Act & Assert
Assert.Throws<InvalidOperationException>(
() => formatter.GetSupportedContentTypes("application/json", typeof(object)));
}
