public void Ctor_ClonesMediaType()
{
// Arrange
MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
MediaTypeHeaderValue mediaType = MediaTypeHeaderValue.Parse("text/test");
// Act
MediaTypeFormatterMatch match = new MediaTypeFormatterMatch(formatter, mediaType, null, MediaTypeFormatterMatchRanking.MatchOnCanWriteType);
// Assert
Assert.Equal(mediaType, match.MediaType);
Assert.NotSame(mediaType, match.MediaType);
}
public void Ctor_InitializesDefaultValues()
{
// Arrange
MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
// Act
MediaTypeFormatterMatch match = new MediaTypeFormatterMatch(formatter, null, null, MediaTypeFormatterMatchRanking.MatchOnCanWriteType);
// Assert
Assert.Same(formatter, match.Formatter);
Assert.Equal(MediaTypeConstants.ApplicationOctetStreamMediaType, match.MediaType);
Assert.Equal(FormattingUtilities.Match, match.Quality);
Assert.Equal(MediaTypeFormatterMatchRanking.MatchOnCanWriteType, match.Ranking);
}
public void AddRequestHeaderMapping1AddsSuccessfully()
{
MediaTypeFormatter formatter = new MockMediaTypeFormatter();
Assert.Equal(0, formatter.MediaTypeMappings.Count);
formatter.AddRequestHeaderMapping("name", "value", StringComparison.CurrentCulture, true, "application/xml");
IEnumerable<RequestHeaderMapping> mappings = formatter.MediaTypeMappings.OfType<RequestHeaderMapping>();
Assert.Equal(1, mappings.Count());
RequestHeaderMapping mapping = mappings.ElementAt(0);
Assert.Equal("name", mapping.HeaderName);
Assert.Equal("value", mapping.HeaderValue);
Assert.Equal(StringComparison.CurrentCulture, mapping.HeaderValueComparison);
Assert.Equal(true, mapping.IsValueSubstring);
Assert.Equal(new MediaTypeHeaderValue("application/xml"), mapping.MediaType);
}
public void MatchType_ReturnsMatch(string[] supportedMediaTypes, string expectedMediaType)
{
// Arrange
MockContentNegotiator negotiator = new MockContentNegotiator();
MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
foreach (string supportedMediaType in supportedMediaTypes)
{
formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse(supportedMediaType));
}
// Act
MediaTypeFormatterMatch match = negotiator.MatchType(typeof(object), formatter);
// Assert
Assert.Same(formatter, match.Formatter);
Assert.Equal(MediaTypeHeaderValue.Parse(expectedMediaType), match.MediaType);
Assert.Equal(1.0, match.Quality);
Assert.Equal(MediaTypeFormatterMatchRanking.MatchOnCanWriteType, match.Ranking);
}
public void MatchAcceptHeader_ReturnsMatch(string[] acceptHeaders, string[] supportedMediaTypes, string expectedMediaType, double expectedQuality, int ranking)
{
// Arrange
MockContentNegotiator negotiator = new MockContentNegotiator();
List<MediaTypeWithQualityHeaderValue> unsortedAcceptHeaders = acceptHeaders.Select(a => MediaTypeWithQualityHeaderValue.Parse(a)).ToList();
IEnumerable<MediaTypeWithQualityHeaderValue> sortedAcceptHeaders = negotiator.SortMediaTypeWithQualityHeaderValuesByQFactor(unsortedAcceptHeaders);
MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
foreach (string supportedMediaType in supportedMediaTypes)
{
formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse(supportedMediaType));
}
// Act
MediaTypeFormatterMatch match = negotiator.MatchAcceptHeader(sortedAcceptHeaders, formatter);
// Assert
if (expectedMediaType == null)
{
Assert.Null(match);
}
else
{
Assert.Same(formatter, match.Formatter);
Assert.Equal(MediaTypeHeaderValue.Parse(expectedMediaType), match.MediaType);
Assert.Equal(expectedQuality, match.Quality);
Assert.Equal(ranking, (int)match.Ranking);
}
}
public void MatchRequestMediaType_ReturnsMatch(string requestMediaType, string[] supportedMediaTypes, string expectedMediaType)
{
// Arrange
MockContentNegotiator negotiator = new MockContentNegotiator();
HttpRequestMessage request = new HttpRequestMessage();
request.Content = new StringContent(String.Empty);
request.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(requestMediaType);
MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
foreach (string supportedMediaType in supportedMediaTypes)
{
formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse(supportedMediaType));
}
// Act
MediaTypeFormatterMatch match = negotiator.MatchRequestMediaType(request, formatter);
// Assert
if (expectedMediaType == null)
{
Assert.Null(match);
}
else
{
Assert.Same(formatter, match.Formatter);
Assert.Equal(MediaTypeHeaderValue.Parse(expectedMediaType), match.MediaType);
Assert.Equal(1.0, match.Quality);
Assert.Equal(MediaTypeFormatterMatchRanking.MatchOnRequestMediaType, match.Ranking);
}
}
public void Negotiate_ForRequestReturnsFirstMatchingFormatter()
{
MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("application/myMediaType");
MediaTypeFormatter formatter1 = new MockMediaTypeFormatter()
{
CanWriteTypeCallback = (Type t) => false
};
MediaTypeFormatter formatter2 = new MockMediaTypeFormatter()
{
CanWriteTypeCallback = (Type t) => true
};
formatter2.SupportedMediaTypes.Add(mediaType);
MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(
new MediaTypeFormatter[]
{
formatter1,
formatter2
});
_request.Content = new StringContent("test", Encoding.UTF8, mediaType.MediaType);
var result = _negotiator.Negotiate(typeof(string), _request, collection);
Assert.Same(formatter2, result.Formatter);
new MediaTypeAssert().AreEqual(mediaType, result.MediaType, "Expected the formatter's media type to be returned.");
}
public void MatchMediaTypeMapping_ReturnsMatch()
{
// Arrange
MockContentNegotiator negotiator = new MockContentNegotiator();
HttpRequestMessage request = new HttpRequestMessage();
MediaTypeHeaderValue mappingMediatype = MediaTypeHeaderValue.Parse("application/other");
MockMediaTypeMapping mockMediaTypeMapping = new MockMediaTypeMapping(mappingMediatype, 0.75);
MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
formatter.MediaTypeMappings.Add(mockMediaTypeMapping);
// Act
MediaTypeFormatterMatch match = negotiator.MatchMediaTypeMapping(request, formatter);
// Assert
Assert.True(mockMediaTypeMapping.WasInvoked);
Assert.Same(request, mockMediaTypeMapping.Request);
Assert.Same(formatter, match.Formatter);
Assert.Equal(mockMediaTypeMapping.MediaType, match.MediaType);
Assert.Equal(mockMediaTypeMapping.MatchQuality, match.Quality);
Assert.Equal(MediaTypeFormatterMatchRanking.MatchOnRequestWithMediaTypeMapping, match.Ranking);
}
public void MatchAcceptHeader_ThrowsOnNull()
{
MockContentNegotiator negotiator = new MockContentNegotiator();
MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
List<MediaTypeWithQualityHeaderValue> sortedAcceptValues = new List<MediaTypeWithQualityHeaderValue>();
Assert.ThrowsArgumentNull(() => negotiator.MatchAcceptHeader(sortedAcceptValues: null, formatter: formatter), "sortedAcceptValues");
Assert.ThrowsArgumentNull(() => negotiator.MatchAcceptHeader(sortedAcceptValues: sortedAcceptValues, formatter: null), "formatter");
}
private static MediaTypeFormatterMatch CreateMatch(double? quality, MediaTypeFormatterMatchRanking ranking)
{
MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/test");
return new MediaTypeFormatterMatch(formatter, mediaType, quality, ranking);
}
public void CreateResponse_AcceptingFormatter_CreatesResponseWithDefaultMediaType()
{
// Arrange
var formatter = new MockMediaTypeFormatter { CallBase = true };
formatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("foo/bar"));
// Act
var response = _request.CreateResponse(HttpStatusCode.MultipleChoices, _value, formatter, mediaType: (string)null);
// Assert
Assert.Equal(HttpStatusCode.MultipleChoices, response.StatusCode);
var content = Assert.IsType<ObjectContent<object>>(response.Content);
Assert.Same(_value, content.Value);
Assert.Same(formatter, content.Formatter);
Assert.Equal("foo/bar", content.Headers.ContentType.MediaType);
}
public void WritingFormatters_FiltersOutNull()
{
// Arrange
MockMediaTypeFormatter writableFormatter = new MockMediaTypeFormatter();
List<MediaTypeFormatter> formatters = new List<MediaTypeFormatter>() { writableFormatter };
MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(formatters);
collection.Add(null);
// Act
MediaTypeFormatter[] writableFormatters = collection.WritingFormatters;
// Assert
MediaTypeFormatter[] expectedFormatters = new MediaTypeFormatter[] { writableFormatter };
Assert.Equal(expectedFormatters, writableFormatters);
}
public void SelectResponseCharacterEncoding_ThrowsOnNull()
{
MockContentNegotiator negotiator = new MockContentNegotiator();
HttpRequestMessage request = new HttpRequestMessage();
MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
Assert.ThrowsArgumentNull(() => negotiator.SelectResponseCharacterEncoding(request: null, formatter: formatter), "request");
Assert.ThrowsArgumentNull(() => negotiator.SelectResponseCharacterEncoding(request: request, formatter: null), "formatter");
}
public void WritingFormatters_Caches()
{
// Arrange
MockMediaTypeFormatter formatter1 = new MockMediaTypeFormatter();
MockMediaTypeFormatter formatter2 = new MockMediaTypeFormatter();
List<MediaTypeFormatter> formatters = new List<MediaTypeFormatter>() { formatter1, formatter2 };
MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(formatters);
// Act
MediaTypeFormatter[] writableFormatters1 = collection.WritingFormatters;
MediaTypeFormatter[] writableFormatters2 = collection.WritingFormatters;
// Assert
MediaTypeFormatter[] expectedFormatters = formatters.ToArray();
Assert.Equal(expectedFormatters, writableFormatters1);
Assert.Same(writableFormatters1, writableFormatters2);
}
public void SelectResponseMediaTypeFormatter_ThrowsOnNull()
{
MockContentNegotiator negotiator = new MockContentNegotiator();
HttpRequestMessage request = new HttpRequestMessage();
MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
Assert.ThrowsArgumentNull(() => negotiator.SelectResponseMediaTypeFormatter(matches: null), "matches");
}
public void MatchType_ThrowsOnNull()
{
MockContentNegotiator negotiator = new MockContentNegotiator();
Type type = typeof(object);
MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
Assert.ThrowsArgumentNull(() => negotiator.MatchType(type: null, formatter: formatter), "type");
Assert.ThrowsArgumentNull(() => negotiator.MatchType(type: type, formatter: null), "formatter");
}
public void MatchRequestMediaType_ThrowsOnNull()
{
MockContentNegotiator negotiator = new MockContentNegotiator();
HttpRequestMessage request = new HttpRequestMessage();
MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
Assert.ThrowsArgumentNull(() => negotiator.MatchRequestMediaType(request: null, formatter: formatter), "request");
Assert.ThrowsArgumentNull(() => negotiator.MatchRequestMediaType(request: request, formatter: null), "formatter");
}
public void SelectResponseCharacterEncoding_SelectsEncoding(string[] acceptCharsetHeaders, string requestEncoding, string[] supportedEncodings, string expectedEncoding)
{
// Arrange
MockContentNegotiator negotiator = new MockContentNegotiator();
HttpRequestMessage request = new HttpRequestMessage();
foreach (string acceptCharsetHeader in acceptCharsetHeaders)
{
request.Headers.AcceptCharset.Add(StringWithQualityHeaderValue.Parse(acceptCharsetHeader));
}
if (requestEncoding != null)
{
Encoding reqEncoding = Encoding.GetEncoding(requestEncoding);
StringContent content = new StringContent("", reqEncoding, "text/plain");
request.Content = content;
}
MockMediaTypeFormatter formatter = new MockMediaTypeFormatter() { CallBase = true };
foreach (string supportedEncoding in supportedEncodings)
{
formatter.SupportedEncodings.Add(Encoding.GetEncoding(supportedEncoding));
}
// Act
Encoding actualEncoding = negotiator.SelectResponseCharacterEncoding(request, formatter);
// Assert
if (expectedEncoding == null)
{
Assert.Null(actualEncoding);
}
else
{
Assert.Equal(Encoding.GetEncoding(expectedEncoding), actualEncoding);
}
}
public void FindWriter_ReturnsFormatterOnMatch(Type variationType, object testData, string mediaType)
{
// Arrange
MockMediaTypeFormatter formatter = new MockMediaTypeFormatter() { CallBase = true };
foreach (string legalMediaType in HttpTestData.LegalMediaTypeStrings)
{
formatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue(mediaType));
}
MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection();
collection.Clear();
collection.Add(formatter);
MediaTypeHeaderValue contentType = new MediaTypeHeaderValue(mediaType);
// Act
MediaTypeFormatter actualFormatter = collection.FindWriter(variationType, contentType);
// Assert
Assert.Same(formatter, actualFormatter);
}
public void FindWriter_ReturnsNullOnNoMatch()
{
// Arrange
MockMediaTypeFormatter formatter = new MockMediaTypeFormatter() { CallBase = true };
MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection();
collection.Clear();
collection.Add(formatter);
MediaTypeHeaderValue contentType = new MediaTypeHeaderValue("text/test");
// Act
MediaTypeFormatter actualFormatter = collection.FindWriter(typeof(object), contentType);
// Assert
Assert.Null(actualFormatter);
}
private static void TestWritingFormattersCacheReset(Action<MediaTypeFormatterCollection> mutation)
{
// Arrange
MockMediaTypeFormatter formatter1 = new MockMediaTypeFormatter();
MockMediaTypeFormatter formatter2 = new MockMediaTypeFormatter();
List<MediaTypeFormatter> formatters = new List<MediaTypeFormatter>() { formatter1, formatter2 };
MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(formatters);
// Act
mutation(collection);
MediaTypeFormatter[] expectedFormatters = collection.ToArray();
MediaTypeFormatter[] writableFormatters = collection.WritingFormatters;
// Assert
Assert.Equal(expectedFormatters, writableFormatters);
}
public void CreateResponse_AcceptingFormatter_WithOverridenMediaTypeHeader_CreatesResponse()
{
// Arrange
var formatter = new MockMediaTypeFormatter { CallBase = true };
formatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("foo/bar"));
// Act
var response = _request.CreateResponse(HttpStatusCode.MultipleChoices, _value, formatter, mediaType: new MediaTypeHeaderValue("bin/baz"));
// Assert
Assert.Equal("bin/baz", response.Content.Headers.ContentType.MediaType);
}
public void WritingFormatters_FiltersOutCanWriteAnyTypesFalse()
{
// Arrange
MockMediaTypeFormatter writableFormatter = new MockMediaTypeFormatter();
MockMediaTypeFormatter readOnlyFormatter = new MockMediaTypeFormatter() { CanWriteAnyTypesReturn = false };
List<MediaTypeFormatter> formatters = new List<MediaTypeFormatter>() { writableFormatter, readOnlyFormatter };
MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(formatters);
// Act
MediaTypeFormatter[] writableFormatters = collection.WritingFormatters;
// Assert
MediaTypeFormatter[] expectedFormatters = new MediaTypeFormatter[] { writableFormatter };
Assert.Equal(expectedFormatters, writableFormatters);
}
