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 MatchType_ReturnsMatch(bool excludeMatchOnTypeOnly, string[] supportedMediaTypes, string expectedMediaType)
{
// Arrange
MockContentNegotiator negotiator = new MockContentNegotiator(excludeMatchOnTypeOnly);
MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
foreach (string supportedMediaType in supportedMediaTypes)
{
formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse(supportedMediaType));
}
// Act
MediaTypeFormatterMatch match = negotiator.MatchType(typeof(object), 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.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 XmlFormatterSetByCtor()
{
XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();
MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(new MediaTypeFormatter[] { formatter });
Assert.Same(formatter, collection.XmlFormatter);
}
public void FormUrlEncodedFormatterSetByCtor()
{
FormUrlEncodedMediaTypeFormatter formatter = new FormUrlEncodedMediaTypeFormatter();
MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(new MediaTypeFormatter[] { formatter });
Assert.Same(formatter, collection.FormUrlEncodedFormatter);
}
public void Constructor_WhenValueAndTypeAreCompatible_SetsValue(Type type, object value)
{
var oc = new ObjectContent(type, value, new JsonMediaTypeFormatter());
Assert.Same(value, oc.Value);
Assert.Equal(type, oc.ObjectType);
}
public void InvokeActionWithExceptionFilters_IfActionTaskIsFaulted_ExecutesFiltersAndReturnsFaultedTaskIfNotHandled()
{
// Arrange
List <string> log = new List <string>();
var exception = new Exception();
var actionTask = TaskHelpers.FromError <HttpResponseMessage>(exception);
Exception exceptionSeenByFilter = null;
var exceptionFilterMock = CreateExceptionFilterMock((ec, ct) =>
{
exceptionSeenByFilter = ec.Exception;
log.Add("exceptionFilter");
return(Task.Factory.StartNew(() => { }));
});
var filters = new[] { exceptionFilterMock.Object };
// Act
var result = ApiController.InvokeActionWithExceptionFilters(actionTask, _actionContextInstance, CancellationToken.None, filters);
// Assert
Assert.NotNull(result);
result.WaitUntilCompleted();
Assert.Equal(TaskStatus.Faulted, result.Status);
Assert.Same(exception, result.Exception.InnerException);
Assert.Same(exception, exceptionSeenByFilter);
Assert.Equal(new string[] { "exceptionFilter" }, log.ToArray());
}
public void FindWriter_ReturnsFormatterOnMatch(Type variationType, object testData, string mediaType)
{
// Arrange
MockMediaTypeFormatter formatter = new MockMediaTypeFormatter()
{
CallBase = true
};
foreach (string legalMediaType in HttpUnitTestDataSets.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 InvokeActionWithExceptionFilters_IfActionTaskIsFaulted_ExecutesFiltersAndReturnsResultIfHandled()
{
// Arrange
List <string> log = new List <string>();
var exception = new Exception();
var actionTask = TaskHelpers.FromError <HttpResponseMessage>(exception);
HttpResponseMessage globalFilterResponse = new HttpResponseMessage();
HttpResponseMessage actionFilterResponse = new HttpResponseMessage();
HttpResponseMessage resultSeenByGlobalFilter = null;
var globalFilterMock = CreateExceptionFilterMock((ec, ct) =>
{
log.Add("globalFilter");
resultSeenByGlobalFilter = ec.Response;
ec.Response = globalFilterResponse;
return(Task.Factory.StartNew(() => { }));
});
var actionFilterMock = CreateExceptionFilterMock((ec, ct) =>
{
log.Add("actionFilter");
ec.Response = actionFilterResponse;
return(Task.Factory.StartNew(() => { }));
});
var filters = new[] { globalFilterMock.Object, actionFilterMock.Object };
// Act
var result = ApiController.InvokeActionWithExceptionFilters(actionTask, _actionContextInstance, CancellationToken.None, filters);
// Assert
Assert.NotNull(result);
result.WaitUntilCompleted();
Assert.Equal(TaskStatus.RanToCompletion, result.Status);
Assert.Same(globalFilterResponse, result.Result);
Assert.Same(actionFilterResponse, resultSeenByGlobalFilter);
Assert.Equal(new string[] { "actionFilter", "globalFilter" }, log.ToArray());
}
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 Task <HttpResponseMessage> RequestGetsSyncContextAsParameter()
{
// Arrange
HttpRequestMessage request = new HttpRequestMessage();
HttpConfiguration config = new HttpConfiguration();
Mock <HttpControllerDispatcher> dispatcherMock = new Mock <HttpControllerDispatcher>(config);
dispatcherMock.Protected().Setup <Task <HttpResponseMessage> >("SendAsync", request, CancellationToken.None).
Returns(TaskHelpers.FromResult <HttpResponseMessage>(request.CreateResponse()));
HttpServer server = new HttpServer(config, dispatcherMock.Object);
HttpMessageInvoker invoker = new HttpMessageInvoker(server);
SynchronizationContext syncContext = new SynchronizationContext();
SynchronizationContext.SetSynchronizationContext(syncContext);
// Act
return(invoker.SendAsync(request, CancellationToken.None).ContinueWith(
(reqTask) =>
{
// Assert
dispatcherMock.Protected().Verify <Task <HttpResponseMessage> >("SendAsync", Times.Once(), request, CancellationToken.None);
Assert.Same(syncContext, request.GetSynchronizationContext());
return reqTask.Result;
}
));
}
public void SetResolverCommonServiceLocator()
{
// Arrange
HttpConfiguration config = new HttpConfiguration();
DependencyResolver resolver = new DependencyResolver(config);
Mock <CommonServiceLocatorSlim> userResolverMock = new Mock <CommonServiceLocatorSlim>();
IHttpActionSelector actionSelector = new Mock <IHttpActionSelector>().Object;
userResolverMock.Setup(ur => ur.GetInstance(typeof(IHttpActionSelector))).Returns(actionSelector).Verifiable();
userResolverMock.Setup(ur => ur.GetAllInstances(typeof(IHttpActionSelector))).Returns(new List <object> {
actionSelector
}).Verifiable();
resolver.SetResolver(userResolverMock.Object);
// Act
object service = resolver.GetService(typeof(IHttpActionSelector));
IEnumerable <object> services = resolver.GetServices(typeof(IHttpActionSelector));
// Assert
userResolverMock.Verify();
Assert.Same(actionSelector, service);
Assert.Same(actionSelector, services.ElementAt(0));
}
public void JsonFormatterSetByCtor()
{
JsonMediaTypeFormatter formatter = new JsonMediaTypeFormatter();
MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(new MediaTypeFormatter[] { formatter });
Assert.Same(formatter, collection.JsonFormatter);
}
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.Default, mediaType.MediaType);
var result = _negotiator.Negotiate(typeof(string), _request, collection);
Assert.Same(formatter2, result.Formatter);
Assert.MediaType.AreEqual(mediaType, result.MediaType, "Expected the formatter's media type to be returned.");
}
public Task SendAsync_DoesNotChangeExistingThreadPrincipal()
{
// Arrange
var config = new HttpConfiguration();
var request = new HttpRequestMessage();
var dispatcherMock = new Mock <HttpControllerDispatcher>(config);
var server = new HttpServer(config, dispatcherMock.Object);
var invoker = new HttpMessageInvoker(server);
var principal = new GenericPrincipal(new GenericIdentity("joe"), new string[0]);
Thread.CurrentPrincipal = principal;
IPrincipal callbackPrincipal = null;
dispatcherMock.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", request, CancellationToken.None)
.Callback(() => callbackPrincipal = Thread.CurrentPrincipal)
.Returns(TaskHelpers.FromResult <HttpResponseMessage>(request.CreateResponse()));
// Act
return(invoker.SendAsync(request, CancellationToken.None)
.ContinueWith(req =>
{
// Assert
Assert.Same(principal, callbackPrincipal);
Assert.Same(principal, Thread.CurrentPrincipal);
}));
}
private static IEnumerable <Task> SyncContextVerifyingEnumerable(SynchronizationContext sc)
{
for (int i = 0; i < 10; i++)
{
Assert.Same(sc, SynchronizationContext.Current);
yield return(TaskHelpers.Completed());
}
}
public void HandleUnauthorizedRequest_SetsResponseWithUnauthorizedStatusCode()
{
_attribute.HandleUnauthorizedRequestPublic(_actionContext);
Assert.NotNull(_actionContext.Response);
Assert.Equal(HttpStatusCode.Unauthorized, _actionContext.Response.StatusCode);
Assert.Same(_request, _actionContext.Response.RequestMessage);
}
public void StaticComparer_Returns_SameInstance()
{
MediaTypeWithQualityHeaderValueComparer comparer1 = MediaTypeWithQualityHeaderValueComparer.QualityComparer;
MediaTypeWithQualityHeaderValueComparer comparer2 = MediaTypeWithQualityHeaderValueComparer.QualityComparer;
Assert.NotNull(comparer1);
Assert.Same(comparer1, comparer2);
}
public void StaticComparerReturnsSameInstance()
{
StringWithQualityHeaderValueComparer comparer1 = StringWithQualityHeaderValueComparer.QualityComparer;
StringWithQualityHeaderValueComparer comparer2 = StringWithQualityHeaderValueComparer.QualityComparer;
Assert.NotNull(comparer1);
Assert.Same(comparer1, comparer2);
}
public void EqualityComparerReturnsMediaTypeHeadeValueEqualityComparer()
{
MediaTypeHeaderValueEqualityComparer comparer1 = MediaTypeHeaderValueEqualityComparer.EqualityComparer;
MediaTypeHeaderValueEqualityComparer comparer2 = MediaTypeHeaderValueEqualityComparer.EqualityComparer;
Assert.NotNull(comparer1);
Assert.Same(comparer1, comparer2);
}
private static IEnumerable <Task <int> > SyncContextVerifyingEnumerable_Generic(SynchronizationContext sc)
{
for (int i = 0; i < 10; i++)
{
Assert.Same(sc, SynchronizationContext.Current);
yield return(TaskHelpers.FromResult(i));
}
}
public void CulturePropertyDefaultsToInvariantCulture()
{
// Arrange
ValueProviderResult result = new ValueProviderResult(null, null, null);
// Act & assert
Assert.Same(CultureInfo.InvariantCulture, result.Culture);
}
public void ControllerContext_HasUrlHelperWithValidContext()
{
HttpControllerContext cc = new HttpControllerContext();
Assert.NotNull(cc.Url);
Assert.IsType <UrlHelper>(cc.Url);
Assert.Same(cc, cc.Url.ControllerContext);
}
public void Parameter_Constructor()
{
string path = "/some/path";
HttpRouteCollection routes = new HttpRouteCollection(path);
HttpConfiguration configuration = new HttpConfiguration(routes);
Assert.Same(routes, configuration.Routes);
Assert.Equal(path, configuration.VirtualPathRoot);
}
public void ResponseConstructor()
{
HttpResponseMessage response = new HttpResponseMessage();
HttpMessageContent instance = new HttpMessageContent(response);
Assert.NotNull(instance);
Assert.Same(response, instance.HttpResponseMessage);
Assert.Null(instance.HttpRequestMessage);
}
public void FromResult_ReturnsCompletedTaskWithGivenResult()
{
string s = "ABC";
Task <string> result = TaskHelpers.FromResult(s);
Assert.NotNull(result);
Assert.True(result.Status == TaskStatus.RanToCompletion);
Assert.Same(s, result.Result);
}
public void FromError_Generic_ReturnsFaultedTaskWithGivenException()
{
var exception = new Exception();
Task <string> result = TaskHelpers.FromError <string>(exception);
Assert.NotNull(result);
Assert.True(result.IsFaulted);
Assert.Same(exception, result.Exception.InnerException);
}
public void Insert_SetsXmlFormatter()
{
MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection();
int count = collection.Count;
XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();
collection.Insert(0, formatter);
Assert.Same(formatter, collection.XmlFormatter);
Assert.Equal(count + 1, collection.Count);
}
public void InsertSetsJsonFormatter()
{
MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection();
int count = collection.Count;
JsonMediaTypeFormatter formatter = new JsonMediaTypeFormatter();
collection.Insert(0, formatter);
Assert.Same(formatter, collection.JsonFormatter);
Assert.Equal(count + 1, collection.Count);
}
public void ConstructorDispatcherSetsUpProperties()
{
// Arrange
Mock <HttpMessageHandler> mockHandler = new Mock <HttpMessageHandler>();
// Act
HttpServer server = new HttpServer(mockHandler.Object);
// Assert
Assert.Same(mockHandler.Object, server.Dispatcher);
}
