public async Task HandleResponseAsync_ReturnsNullProxyCredentialsIfNoProxy()
{
var plugin = CreateMockPlugin();
using (var provider = new GetCredentialsRequestHandler(
plugin,
proxy: null,
credentialService: Mock.Of <ICredentialService>()))
{
var request = CreateRequest(
MessageType.Request,
new GetCredentialsRequest(_packageSource.Source, HttpStatusCode.ProxyAuthenticationRequired));
var responseHandler = new Mock <IResponseHandler>(MockBehavior.Strict);
responseHandler.Setup(x => x.SendResponseAsync(
It.Is <Message>(r => r == request),
It.Is <GetCredentialsResponse>(r => r.ResponseCode == MessageResponseCode.NotFound &&
r.Username == null && r.Password == null),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(0));
await provider.HandleResponseAsync(
Mock.Of <IConnection>(),
request,
responseHandler.Object,
CancellationToken.None);
responseHandler.Verify();
}
}
internal static async Task <PluginFindPackageByIdResourceTest> CreateAsync(
MessageResponseCode responseCode = MessageResponseCode.Error)
{
var packageIdentity = new PackageIdentity(id: "a", version: NuGetVersion.Parse("1.0.0"));
var testDirectory = TestDirectory.Create();
var packageSource = new PackageSource("http://unit.test");
var package = await SimpleTestPackageUtility.CreateFullPackageAsync(
testDirectory.Path,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString());
var packageBytes = File.ReadAllBytes(package.FullName);
var plugin = new Mock <IPlugin>();
var dispatcher = new Mock <IMessageDispatcher>();
var connection = new Mock <IConnection>();
dispatcher.SetupGet(x => x.RequestHandlers)
.Returns(new RequestHandlers());
connection.SetupGet(x => x.MessageDispatcher)
.Returns(dispatcher.Object);
var versions = responseCode == MessageResponseCode.Success ? new[] { "1.0.0", "2.0.0", "3.0.0" } : null;
var response = new GetPackageVersionsResponse(responseCode, versions);
connection.Setup(x => x.SendRequestAndReceiveResponseAsync <GetPackageVersionsRequest, GetPackageVersionsResponse>(
It.Is <MessageMethod>(m => m == MessageMethod.GetPackageVersions),
It.Is <GetPackageVersionsRequest>(
c => string.Equals(c.PackageId, packageIdentity.Id, StringComparison.OrdinalIgnoreCase) &&
c.PackageSourceRepository == packageSource.Source),
It.IsAny <CancellationToken>()))
.ReturnsAsync(response);
plugin.SetupGet(x => x.Connection)
.Returns(connection.Object);
var utilities = new Mock <IPluginMulticlientUtilities>();
var credentialService = new Mock <ICredentialService>();
var credentialsProvider = new GetCredentialsRequestHandler(
plugin.Object,
proxy: null,
credentialService: credentialService.Object);
var resource = new PluginFindPackageByIdResource(
plugin.Object,
utilities.Object,
packageSource);
return(new PluginFindPackageByIdResourceTest(
resource,
package,
packageIdentity,
connection,
new SourceCacheContext(),
testDirectory));
}
public async Task HandleResponseAsync_ReturnsProxyCredentialsFromCredentialServiceIfFound()
{
var proxyUri = new Uri("https://proxy.unit.test");
var networkCredential = new NetworkCredential(userName: "******", password: "******");
var credentialService = new Mock <ICredentialService>();
var credentials = new Mock <ICredentials>();
var proxy = new Mock <IWebProxy>();
proxy.Setup(x => x.GetProxy(It.IsAny <Uri>()))
.Returns(proxyUri);
credentials.Setup(x => x.GetCredential(
It.Is <Uri>(u => u == proxyUri),
It.Is <string>(a => a == "Basic")))
.Returns(networkCredential);
credentialService.Setup(x => x.GetCredentialsAsync(
It.Is <Uri>(u => u == _packageSource.SourceUri),
It.Is <IWebProxy>(p => p == proxy.Object),
It.Is <CredentialRequestType>(t => t == CredentialRequestType.Proxy),
It.IsNotNull <string>(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(credentials.Object));
var plugin = CreateMockPlugin();
using (var provider = new GetCredentialsRequestHandler(plugin, proxy.Object, credentialService.Object))
{
var request = CreateRequest(
MessageType.Request,
new GetCredentialsRequest(_packageSource.Source, HttpStatusCode.ProxyAuthenticationRequired));
var responseHandler = new Mock <IResponseHandler>(MockBehavior.Strict);
responseHandler.Setup(x => x.SendResponseAsync(
It.Is <Message>(r => r == request),
It.Is <GetCredentialsResponse>(r => r.ResponseCode == MessageResponseCode.Success &&
r.Username == "a" && r.Password == "b"),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(0));
await provider.HandleResponseAsync(
Mock.Of <IConnection>(),
request,
responseHandler.Object,
CancellationToken.None);
responseHandler.Verify();
}
}
public void Dispose_DisposesDisposables()
{
var plugin = new Mock <IPlugin>(MockBehavior.Strict);
plugin.Setup(x => x.Dispose());
var provider = new GetCredentialsRequestHandler(
plugin.Object,
Mock.Of <IWebProxy>(),
Mock.Of <ICredentialService>());
provider.Dispose();
plugin.Verify(x => x.Dispose(), Times.Once);
}
public async Task HandleResponseAsync_ReturnsNullProxyCredentialsIfNoCredentials()
{
var credentialService = new Mock <ICredentialService>();
var credentials = new Mock <ICredentials>();
var proxy = Mock.Of <IWebProxy>();
credentials.Setup(x => x.GetCredential(
It.Is <Uri>(u => u == _packageSource.SourceUri),
It.Is <string>(a => a == null)))
.Returns <NetworkCredential>(null);
credentialService.Setup(x => x.GetCredentialsAsync(
It.Is <Uri>(uri => uri == _packageSource.SourceUri),
It.Is <IWebProxy>(p => p == proxy),
It.Is <CredentialRequestType>(t => t == CredentialRequestType.Proxy),
It.IsNotNull <string>(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(credentials.Object));
var plugin = CreateMockPlugin();
using (var provider = new GetCredentialsRequestHandler(plugin, proxy, credentialService.Object))
{
var request = CreateRequest(
MessageType.Request,
new GetCredentialsRequest(_packageSource.Source, HttpStatusCode.ProxyAuthenticationRequired));
var responseHandler = new Mock <IResponseHandler>(MockBehavior.Strict);
responseHandler.Setup(x => x.SendResponseAsync(
It.Is <Message>(r => r == request),
It.Is <GetCredentialsResponse>(r => r.ResponseCode == MessageResponseCode.NotFound &&
r.Username == null && r.Password == null),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(0));
await provider.HandleResponseAsync(
Mock.Of <IConnection>(),
request,
responseHandler.Object,
CancellationToken.None);
responseHandler.Verify();
}
}
public async Task HandleResponseAsync_ReturnsNotFoundIfPackageSourceNotFound()
{
var credentialService = new Mock <ICredentialService>(MockBehavior.Strict);
credentialService.Setup(x => x.GetCredentialsAsync(
It.IsNotNull <Uri>(),
It.IsNotNull <IWebProxy>(),
It.Is <CredentialRequestType>(c => c == CredentialRequestType.Unauthorized),
It.IsNotNull <string>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync((ICredentials)null);
var plugin = CreateMockPlugin();
using (var provider = new GetCredentialsRequestHandler(
plugin,
Mock.Of <IWebProxy>(),
credentialService.Object))
{
var request = CreateRequest(
MessageType.Request,
new GetCredentialsRequest("https://unit.test", HttpStatusCode.Unauthorized));
var responseHandler = new Mock <IResponseHandler>(MockBehavior.Strict);
responseHandler.Setup(x => x.SendResponseAsync(
It.Is <Message>(r => r == request),
It.Is <GetCredentialsResponse>(r => r.ResponseCode == MessageResponseCode.NotFound &&
r.Username == null && r.Password == null),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(0));
await provider.HandleResponseAsync(
Mock.Of <IConnection>(),
request,
responseHandler.Object,
CancellationToken.None);
responseHandler.Verify();
}
}
