internal HttpSourceAuthenticationHandler(
Uri source,
DefaultHttpClientHandler clientHandler,
ICredentialService credentialService)
: this(source, clientHandler, clientHandler, credentialService)
{
}
public override HttpMessageHandler CreateHttpMessageHandler(Uri uri, HttpClientSettings settings)
{
var proxy = WebRequestHelper.ProxyCache.GetProxy(uri);
var clientHandler = new DefaultHttpClientHandler(proxy, settings);
HttpMessageHandler messageHandler = clientHandler;
if (proxy != null)
{
messageHandler = new ProxyAuthenticationHandler(clientHandler, HttpClientProvider.CredentialService, WebRequestHelper.ProxyCache)
{
NonInteractive = settings.NonInteractive
};
}
if (settings.SourceAuthenticationRequired)
{
var innerHandler = messageHandler;
messageHandler = new HttpSourceAuthenticationHandler(uri, clientHandler, HttpClientProvider.CredentialService)
{
InnerHandler = innerHandler
};
}
return(messageHandler);
}
public async Task SendAsync_WhenCredentialServiceThrows_Returns401()
{
// Arrange
var packageSource = new Uri("http://package.source.net");
var clientHandler = new DefaultHttpClientHandler(null, new HttpClientSettings());
var credentialService = Mock.Of <ICredentialService> ();
Mock.Get(credentialService)
.Setup(
x => x.GetCredentialsAsync(
packageSource,
It.IsAny <IWebProxy> (),
CredentialType.RequestCredentials,
It.IsAny <bool> (),
It.IsAny <CancellationToken> ()))
.Throws(new InvalidOperationException("Credential service failed acquring user credentials"));
var handler = new HttpSourceAuthenticationHandler(packageSource, clientHandler, credentialService);
int retryCount = 0;
var innerHandler = new LambdaMessageHandler(
_ => {
retryCount++;
return(new HttpResponseMessage(HttpStatusCode.Unauthorized));
});
handler.InnerHandler = innerHandler;
// Act
var response = await SendAsync(handler);
// Assert
Assert.NotNull(response);
Assert.AreEqual(HttpStatusCode.Unauthorized, response.StatusCode);
Assert.AreEqual(1, retryCount);
Mock.Get(credentialService)
.Verify(
x => x.GetCredentialsAsync(
packageSource,
It.IsAny <IWebProxy> (),
CredentialType.RequestCredentials,
It.IsAny <bool> (),
It.IsAny <CancellationToken> ()),
Times.Once());
}
public async Task SendAsync_WithWrongCredentials_StopsRetryingAfter3Times()
{
// Arrange
var packageSource = new Uri("http://package.source.net");
var clientHandler = new DefaultHttpClientHandler(null, new HttpClientSettings());
var credentialService = Mock.Of <ICredentialService> ();
Mock.Get(credentialService)
.Setup(
x => x.GetCredentialsAsync(
packageSource,
It.IsAny <IWebProxy> (),
CredentialType.RequestCredentials,
It.IsAny <bool> (),
It.IsAny <CancellationToken> ()))
.Returns(() => Task.FromResult <ICredentials> (new NetworkCredential()));
var handler = new HttpSourceAuthenticationHandler(packageSource, clientHandler, credentialService);
int retryCount = 0;
var innerHandler = new LambdaMessageHandler(
_ => {
retryCount++;
return(new HttpResponseMessage(HttpStatusCode.Unauthorized));
});
handler.InnerHandler = innerHandler;
// Act
var response = await SendAsync(handler);
// Assert
Assert.NotNull(response);
Assert.AreEqual(HttpStatusCode.Unauthorized, response.StatusCode);
Assert.AreEqual(HttpSourceAuthenticationHandler.MaxAuthRetries + 1, retryCount);
Mock.Get(credentialService)
.Verify(
x => x.GetCredentialsAsync(
packageSource,
It.IsAny <IWebProxy> (),
CredentialType.RequestCredentials,
It.IsAny <bool> (),
It.IsAny <CancellationToken> ()),
Times.Exactly(HttpSourceAuthenticationHandler.MaxAuthRetries));
}
public async Task SendAsync_WhenOperationCanceledExceptionThrownDuringAcquiringCredentials_Throws()
{
// Arrange
var packageSource = new Uri("http://package.source.net");
var clientHandler = new DefaultHttpClientHandler(null, new HttpClientSettings());
var cts = new CancellationTokenSource();
var credentialService = Mock.Of <ICredentialService> ();
Mock.Get(credentialService)
.Setup(
x => x.GetCredentialsAsync(
packageSource,
It.IsAny <IWebProxy> (),
CredentialType.RequestCredentials,
It.IsAny <bool> (),
It.IsAny <CancellationToken> ()))
.ThrowsAsync(new OperationCanceledException())
.Callback(() => cts.Cancel());
var handler = new HttpSourceAuthenticationHandler(packageSource, clientHandler, credentialService);
int retryCount = 0;
var innerHandler = new LambdaMessageHandler(
_ => {
retryCount++;
return(new HttpResponseMessage(HttpStatusCode.Unauthorized));
});
handler.InnerHandler = innerHandler;
// Act & Assert
await AssertThrowsAsync <OperationCanceledException> (
() => SendAsync (handler));
Assert.AreEqual(1, retryCount);
Mock.Get(credentialService)
.Verify(
x => x.GetCredentialsAsync(
packageSource,
It.IsAny <IWebProxy> (),
CredentialType.RequestCredentials,
It.IsAny <bool> (),
It.IsAny <CancellationToken> ()),
Times.Once);
}
public async Task SendAsync_WithUnauthenticatedSource_PassesThru()
{
var packageSource = new Uri("http://package.source.net");
var clientHandler = new DefaultHttpClientHandler(null, new HttpClientSettings());
var credentialService = new Mock <ICredentialService> (MockBehavior.Strict);
var handler = new HttpSourceAuthenticationHandler(packageSource, clientHandler, credentialService.Object)
{
InnerHandler = GetLambdaMessageHandler(HttpStatusCode.OK)
};
var response = await SendAsync(handler);
Assert.NotNull(response);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
public async Task SendAsync_WithAcquiredCredentialsOn403_RetriesRequest()
{
// Arrange
var packageSource = new Uri("http://package.source.net");
var clientHandler = new DefaultHttpClientHandler(null, new HttpClientSettings());
var credentialService = Mock.Of <ICredentialService> ();
Mock.Get(credentialService)
.Setup(
x => x.GetCredentialsAsync(
packageSource,
It.IsAny <IWebProxy> (),
CredentialType.RequestCredentials,
It.IsAny <bool> (),
It.IsAny <CancellationToken> ()))
.Returns(() => Task.FromResult <ICredentials> (new NetworkCredential()));
var handler = new HttpSourceAuthenticationHandler(packageSource, clientHandler, credentialService)
{
InnerHandler = GetLambdaMessageHandler(
HttpStatusCode.Forbidden, HttpStatusCode.OK)
};
// Act
var response = await SendAsync(handler);
// Assert
Assert.NotNull(response);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Mock.Get(credentialService)
.Verify(
x => x.GetCredentialsAsync(
packageSource,
It.IsAny <IWebProxy> (),
CredentialType.RequestCredentials,
It.IsAny <bool> (),
It.IsAny <CancellationToken> ()),
Times.Once());
}
public void Constructor_WithSourceCredentials_InitializesClientHandler()
{
if (CredentialCache.DefaultNetworkCredentials == null)
{
Assert.Ignore("No default network credentials");
}
var packageSource = new Uri("http://package.source.net");
var credentials = new NetworkCredential("user", "password");
var a = CredentialCache.DefaultNetworkCredentials;
var clientHandler = new DefaultHttpClientHandler(null, new HttpClientSettings());
var credentialService = Mock.Of <ICredentialService> ();
var handler = new HttpSourceAuthenticationHandler(packageSource, clientHandler, credentialService);
Assert.NotNull(clientHandler.Credentials);
var actualCredentials = clientHandler.Credentials.GetCredential(packageSource, "Basic");
Assert.AreEqual(CredentialCache.DefaultNetworkCredentials, actualCredentials);
}
