public async Task HandlerShouldProcessWhenValid()
{
// arrange
var responseProviderMock = new Mock <IResponseProvider>(MockBehavior.Strict);
Expression <Func <IResponseProvider, IEnumerable <IHateoasLink> > > createExpression = rp => rp.CreateLinks(It.IsAny <HttpResponseMessage>());
responseProviderMock
.Setup(createExpression)
.Returns(new List <IHateoasLink>());
var handler = new HateoasHttpHandler(responseProviderMock.Object, new List <IMessageSerializer>())
{
InnerHandler = new TestHandler((message, token) => new HttpResponseMessage(HttpStatusCode.Accepted)
{
Content = new ObjectContent(typeof(Person), new Person(), new JsonMediaTypeFormatter())
})
};
var requestMessage = new HttpRequestMessage(HttpMethod.Get, "http://hateoas.net");
var client = new HttpClient(handler);
// act
var result = await client.SendAsync(requestMessage);
// assert
responseProviderMock.Verify(createExpression, Times.Once);
}
public static void Startup <TRegistrationClass>(
TRegistrationClass registrationClass,
IHttpConfiguration configuration,
IAuthorizationProvider authorizationProvider = null,
IDependencyResolver dependencyResolver = null,
IList <IMessageSerializer> messageSerializers = null)
where TRegistrationClass : IHateoasRegistrationProfile
{
var linkBuilderFactory = new LinkBuilderFactory();
// todo: this is not very clean; user dependencyresolver etc
if (authorizationProvider == null)
{
var httpContextWrapper = new HttpContextWrapper(HttpContext.Current);
authorizationProvider = new WebApiAuthorizationProvider(httpContextWrapper);
}
var idFromExpressionProcessor = new IdFromExpressionProcessor(dependencyResolver);
var argumentsDefinitionsProcessor = new ArgumentDefinitionsProcessor();
var templateArgumentsProcessor = new TemplateArgumentsProcessor();
var linkFactory = new LinkFactory(
linkBuilderFactory: linkBuilderFactory,
authorizationProvider: authorizationProvider,
idFromExpressionProcessor: idFromExpressionProcessor,
argumentsDefinitionsProcessor: argumentsDefinitionsProcessor,
templateArgumentsProcessor: templateArgumentsProcessor
);
var inMemoryGenericLinksForMethodsCache = new InMemoryCache <int, MethodInfo>();
var linksForFuncProvider =
new ConfigurationProviderGetLinksForFuncProvider(inMemoryGenericLinksForMethodsCache);
var getLinksForMethodCache =
new InMemoryCache <Type, Func <ConfigurationProvider, object, IEnumerable <IHateoasLink> > >();
var configurationProvider = new ConfigurationProvider(configuration, linkFactory, linksForFuncProvider,
getLinksForMethodCache);
var responseProvider = new ResponseProvider(configurationProvider);
var handler = new HateoasHttpHandler(responseProvider, messageSerializers ?? new List <IMessageSerializer>());
configuration.MessageHandlers.Add(handler);
var container = HateoasContainerFactory.Create(configuration);
registrationClass.Register(container);
}
protected async Task <TestResult> RegisterGetAndAssertResponse(bool isHateoasResponse, object data, int linkCount, int commandCount)
{
Hateoas.Startup(RegistrationClass, _httpConfigurationWrapper, _authorizationProviderMock.Object, _dependencyResolver.Object);
var handler = new HateoasHttpHandler(_responseProvider, new List <IMessageSerializer>())
{
InnerHandler = new TestHandler((request, cancellationToken) => Response)
};
var client = new HttpClient(handler);
var result = await client.SendAsync(Request);
var testResult = new TestResult(result);
await testResult.GetResponseString();
// assert
testResult.IsHateoasResponse.Should().Be(isHateoasResponse);
testResult.HateoasResponse.Data.Should().Be(data);
testResult.HateoasResponse.Links.Should().HaveCount(linkCount);
testResult.HateoasResponse.Commands.Should().HaveCount(commandCount);
return(testResult);
}
