public async Task GetCredentialsAsync_FirstCallHasRetryFalse()
{
// Arrange
IEnumerable <ICredentialProvider> providers = new[] { _mockProvider.Object };
var service = new CredentialService(
new AsyncLazy <IEnumerable <ICredentialProvider> >(() => Task.FromResult(providers)),
nonInteractive: false,
handlesDefaultCredentials: true);
_mockProvider.Setup(
x => x.GetAsync(
It.IsAny <Uri>(),
It.IsAny <IWebProxy>(),
It.IsAny <CredentialRequestType>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new CredentialResponse(new NetworkCredential())));
var uri1 = new Uri("http://uri1");
var uri2 = new Uri("http://uri2");
// Act
var result1 = await service.GetCredentialsAsync(
uri1,
proxy : null,
type : CredentialRequestType.Unauthorized,
message : "A",
cancellationToken : CancellationToken.None);
var result2 = await service.GetCredentialsAsync(
uri2,
proxy : null,
type : CredentialRequestType.Unauthorized,
message : "B",
cancellationToken : CancellationToken.None);
// Assert
_mockProvider.Verify(x => x.GetAsync(
uri1,
/*webProxy*/ null,
/*type*/ CredentialRequestType.Unauthorized,
/*message*/ "A",
/*isRetry*/ false,
/*nonInteractive*/ false,
CancellationToken.None));
_mockProvider.Verify(x => x.GetAsync(
uri2,
/*webProxy*/ null,
/*type*/ CredentialRequestType.Unauthorized,
/*message*/ "B",
/*isRetry*/ false,
/*nonInteractive*/ false,
CancellationToken.None));
}
public async Task GetCredentials_SecondCallHasRetryTrue()
{
// Arrange
var service = new CredentialService(
new[] { _mockProvider.Object },
TestableErrorWriter,
nonInteractive: false);
_mockProvider.Setup(
x => x.GetAsync(
It.IsAny <Uri>(),
It.IsAny <IWebProxy>(),
It.IsAny <CredentialRequestType>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new CredentialResponse(new NetworkCredential())));
var uri1 = new Uri("http://uri1");
var webProxy = new WebProxy();
// Act
await service.GetCredentialsAsync(
uri1,
proxy : null,
type : CredentialRequestType.Unauthorized,
message : null,
cancellationToken : CancellationToken.None);
await service.GetCredentialsAsync(
uri1,
webProxy,
type : CredentialRequestType.Unauthorized,
message : null,
cancellationToken : CancellationToken.None);
// Assert
_mockProvider.Verify(x => x.GetAsync(
uri1,
null,
/*type*/ CredentialRequestType.Unauthorized,
/*message*/ null,
/*isRetry*/ false,
/*nonInteractive*/ false,
CancellationToken.None));
_mockProvider.Verify(x => x.GetAsync(
uri1,
webProxy,
/*type*/ CredentialRequestType.Unauthorized,
/*message*/ null,
/*isRetry*/ true,
/*nonInteractive*/ false,
CancellationToken.None));
}
public async Task GetCredentialsAsync_WhenUriHasSameAuthority_ThenReturnsCachedCredential()
{
// Arrange
IEnumerable <ICredentialProvider> providers = new[] { _mockProvider.Object };
var service = new CredentialService(
new AsyncLazy <IEnumerable <ICredentialProvider> >(() => Task.FromResult(providers)),
nonInteractive: false,
handlesDefaultCredentials: true);
_mockProvider
.Setup(x => x.GetAsync(
It.IsAny <Uri>(),
It.IsAny <IWebProxy>(),
It.IsAny <CredentialRequestType>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(new CredentialResponse(new NetworkCredential())));
var uri1 = new Uri("http://host/some/path");
var uri2 = new Uri("http://host/some2/path2");
// Act
var result1 = await service.GetCredentialsAsync(
uri1,
proxy : null,
type : CredentialRequestType.Unauthorized,
message : null,
cancellationToken : CancellationToken.None);
var result2 = await service.GetCredentialsAsync(
uri2,
proxy : null,
type : CredentialRequestType.Unauthorized,
message : null,
cancellationToken : CancellationToken.None);
// Assert
Assert.Same(result1, result2);
_mockProvider.Verify(
x => x.GetAsync(
It.IsAny <Uri>(),
It.IsAny <IWebProxy>(),
It.IsAny <CredentialRequestType>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()),
Times.Once);
}
public async Task GetCredentials_NullResponsesAreCached()
{
// Arrange
var service = new CredentialService(
new[] { _mockProvider.Object },
TestableErrorWriter,
nonInteractive: false);
_mockProvider
.Setup(x => x.GetAsync(
It.IsAny <Uri>(),
It.IsAny <IWebProxy>(),
It.IsAny <CredentialRequestType>(),
It.IsAny <string>(),
It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(new CredentialResponse(CredentialStatus.ProviderNotApplicable)));
var uri1 = new Uri("http://host/some/path");
var uri2 = new Uri("http://host/some2/path2");
// Act
var result1 = await service.GetCredentialsAsync(
uri1,
proxy : null,
type : CredentialRequestType.Unauthorized,
message : null,
cancellationToken : CancellationToken.None);
var result2 = await service.GetCredentialsAsync(
uri2,
proxy : null,
type : CredentialRequestType.Unauthorized,
message : null,
cancellationToken : CancellationToken.None);
// Assert
Assert.Null(result1);
Assert.Null(result2);
_mockProvider.Verify(
x => x.GetAsync(
It.IsAny <Uri>(),
It.IsAny <IWebProxy>(),
It.IsAny <CredentialRequestType>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()),
Times.Once);
}
public async Task GetCredentials_WhenRetry_ThenDoesNotReturnCachedCredential()
{
// Arrange
var service = new CredentialService(
new[] { _mockProvider.Object },
TestableErrorWriter,
nonInteractive: false);
_mockProvider
.Setup(x => x.GetAsync(
It.IsAny <Uri>(),
It.IsAny <IWebProxy>(),
It.IsAny <CredentialRequestType>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(new CredentialResponse(new NetworkCredential())));
var uri1 = new Uri("http://uri1");
// Act
var result1 = await service.GetCredentialsAsync(
uri1,
proxy : null,
type : CredentialRequestType.Unauthorized,
message : null,
cancellationToken : CancellationToken.None);
var result2 = await service.GetCredentialsAsync(
uri1,
proxy : null,
type : CredentialRequestType.Unauthorized,
message : null,
cancellationToken : CancellationToken.None);
// Assert
Assert.NotSame(result1, result2);
_mockProvider.Verify(
x => x.GetAsync(
It.IsAny <Uri>(),
It.IsAny <IWebProxy>(),
It.IsAny <CredentialRequestType>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()),
Times.Exactly(2));
}
public async Task TryGetLastKnownGoodCredentialsFromCache_DoesNotReturnUnsuccessfulCredentials(
CredentialStatus credentialStatus,
bool isProxy)
{
var provider = new Mock <ICredentialProvider>(MockBehavior.Strict);
provider.Setup(x => x.GetAsync(
It.IsAny <Uri>(),
It.IsAny <IWebProxy>(),
It.IsAny <CredentialRequestType>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(new CredentialResponse(credentialStatus)));
provider.Setup(x => x.Id).Returns("a");
var service = new CredentialService(new[] { provider.Object }, nonInteractive: false);
var uri = new Uri("https://unit.test");
var type = isProxy ? CredentialRequestType.Proxy : CredentialRequestType.Unauthorized;
var credentials = await service.GetCredentialsAsync(
uri,
proxy : null,
type : type,
message : null,
cancellationToken : CancellationToken.None);
ICredentials cachedCredentials;
var wasCacheHit = service.TryGetLastKnownGoodCredentialsFromCache(uri, isProxy, out cachedCredentials);
Assert.False(wasCacheHit);
}
public async Task TryGetLastKnownGoodCredentialsFromCache_ReturnsCredentialsForCacheHit(bool isProxy)
{
var networkCredential = new NetworkCredential();
var provider = new Mock <ICredentialProvider>(MockBehavior.Strict);
provider.Setup(x => x.GetAsync(
It.IsAny <Uri>(),
It.IsAny <IWebProxy>(),
It.IsAny <CredentialRequestType>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(new CredentialResponse(networkCredential)));
provider.Setup(x => x.Id).Returns("a");
IEnumerable <ICredentialProvider> providers = new[] { provider.Object };
var service = new CredentialService(new AsyncLazy <IEnumerable <ICredentialProvider> >(() => Task.FromResult(providers)), nonInteractive: false, handlesDefaultCredentials: true);
var uri = new Uri("https://unit.test");
var type = isProxy ? CredentialRequestType.Proxy : CredentialRequestType.Unauthorized;
var credentials = await service.GetCredentialsAsync(
uri,
proxy : null,
type : type,
message : null,
cancellationToken : CancellationToken.None);
ICredentials cachedCredentials;
var wasCacheHit = service.TryGetLastKnownGoodCredentialsFromCache(uri, isProxy, out cachedCredentials);
Assert.True(wasCacheHit);
Assert.Same(networkCredential, credentials);
Assert.Same(credentials, cachedCredentials);
}
/// <summary>
/// Set default credential provider for the HttpClient, which is used by V2 sources.
/// Also set up authenticated proxy handling for V3 sources.
/// </summary>
private void SetDefaultCredentialProvider()
{
var credentialService = new CredentialService(
GetCredentialProviders(),
this._outputConsoleLogger.OutputConsole.WriteLine,
nonInteractive: false);
HttpClient.DefaultCredentialProvider = new CredentialServiceAdapter(credentialService);
NuGet.Protocol.Core.v3.HttpHandlerResourceV3.CredentialSerivce = credentialService;
NuGet.Protocol.Core.v3.HttpHandlerResourceV3.PromptForCredentialsAsync =
async (uri, type, message, cancellationToken) =>
{
// Get the proxy for this URI so we can pass it to the credentialService methods
// this lets them use the proxy if they have to hit the network.
var proxyCache = ProxyCache.Instance;
var proxy = proxyCache?.GetProxy(uri);
return await credentialService.GetCredentialsAsync(
uri,
proxy,
type,
message,
cancellationToken);
};
NuGet.Protocol.Core.v3.HttpHandlerResourceV3.CredentialsSuccessfullyUsed = (uri, credentials) =>
{
NuGet.CredentialStore.Instance.Add(uri, credentials);
NuGet.Configuration.CredentialStore.Instance.Add(uri, credentials);
};
}
public async Task GetCredentials_PassesAllParametersToProviders()
{
// Arrange
var service = new CredentialService(
new[] { _mockProvider.Object },
TestableErrorWriter,
nonInteractive: true);
var webProxy = new WebProxy();
var uri = new Uri("http://uri");
// Act
await service.GetCredentialsAsync(
uri,
webProxy,
CredentialRequestType.Proxy,
message : "A",
cancellationToken : CancellationToken.None);
// Assert
_mockProvider.Verify(x => x.GetAsync(
uri,
webProxy,
/*type*/ CredentialRequestType.Proxy,
/*message*/ "A",
/*isRetry*/ It.IsAny <bool>(),
/*nonInteractive*/ true,
CancellationToken.None));
}
public async Task GetCredentialsAsync_PassesAllParametersToProviders()
{
IEnumerable <ICredentialProvider> providers = new[] { _mockProvider.Object };
// Arrange
var service = new CredentialService(
new AsyncLazy <IEnumerable <ICredentialProvider> >(() => Task.FromResult(providers)),
nonInteractive: true,
handlesDefaultCredentials: true);
var webProxy = new WebProxy();
var uri = new Uri("http://uri");
// Act
await service.GetCredentialsAsync(
uri,
webProxy,
CredentialRequestType.Proxy,
message : "A",
cancellationToken : CancellationToken.None);
// Assert
_mockProvider.Verify(x => x.GetAsync(
uri,
webProxy,
/*type*/ CredentialRequestType.Proxy,
/*message*/ "A",
/*isRetry*/ It.IsAny <bool>(),
/*nonInteractive*/ true,
CancellationToken.None));
}
private async Task SaveNewCredential()
{
await CredentialService.AddCredentialAsync(NewCredential);
SavedCredentials = await CredentialService.GetCredentialsAsync();
NewCredential = new JiraCredential();
}
public async Task GetCredentialsAsync_ThrowsForNullUri()
{
var service = new CredentialService(new AsyncLazy <IEnumerable <ICredentialProvider> >(() => Task.FromResult(Enumerable.Empty <ICredentialProvider>())), nonInteractive: true, handlesDefaultCredentials: true);
var exception = await Assert.ThrowsAsync <ArgumentNullException>(
() => service.GetCredentialsAsync(
uri: null,
proxy: Mock.Of <IWebProxy>(),
type: CredentialRequestType.Unauthorized,
message: "a",
cancellationToken: CancellationToken.None));
Assert.Equal("uri", exception.ParamName);
}
public async Task GetCredentialProvidersExecutedOnlyOnce()
{
var counter = new CallCounter();
var service = new CredentialService(new AsyncLazy <IEnumerable <ICredentialProvider> >(() => counter.GetProviders()), nonInteractive: true, handlesDefaultCredentials: true);
var uri1 = new Uri("http://uri1");
// Act
var result1 = await service.GetCredentialsAsync(
uri1,
proxy : null,
type : CredentialRequestType.Unauthorized,
message : null,
cancellationToken : CancellationToken.None);
var result2 = await service.GetCredentialsAsync(
uri1,
proxy : null,
type : CredentialRequestType.Unauthorized,
message : null,
cancellationToken : CancellationToken.None);
Assert.Equal(1, counter.CallCount);
}
public void GetCredentialsAsync_SingleThreadedAccessToEachProvider()
{
// Arrange
IEnumerable <ICredentialProvider> providers = new[] { _mockProvider.Object };
var service = new CredentialService(
new AsyncLazy <IEnumerable <ICredentialProvider> >(() => Task.FromResult(providers)),
nonInteractive: true,
handlesDefaultCredentials: true);
var webProxy = new WebProxy();
var uri = new Uri("http://uri");
_mockProvider
.Setup(x => x.GetAsync(
It.IsAny <Uri>(),
It.IsAny <IWebProxy>(),
It.IsAny <CredentialRequestType>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()))
.Returns(() =>
{
_lockTestConcurrencyCount++;
Assert.Equal(1, _lockTestConcurrencyCount);
_lockTestConcurrencyCount--;
return(Task.FromResult(new CredentialResponse(new NetworkCredential())));
});
var tasks = new Task[10];
// Act
for (var x = 0; x < 10; x++)
{
tasks[x] = service.GetCredentialsAsync(
uri,
webProxy,
type: CredentialRequestType.Unauthorized,
message: null,
cancellationToken: CancellationToken.None);
}
Task.WaitAll(tasks);
// Assert
// in this case, assert is done during provider access
}
/// <summary>
/// Set default credential provider for the HttpClient, which is used by V2 sources.
/// Also set up authenticated proxy handling for V3 sources.
/// </summary>
protected void SetDefaultCredentialProvider()
{
var credentialService = new CredentialService(GetCredentialProviders(), Console.WriteError, NonInteractive);
HttpClient.DefaultCredentialProvider = new CredentialServiceAdapter(credentialService);
NuGet.Protocol.Core.v3.HttpHandlerResourceV3.CredentialSerivce = credentialService;
NuGet.Protocol.Core.v3.HttpHandlerResourceV3.PromptForCredentialsAsync =
async(uri, type, message, cancellationToken) => await credentialService.GetCredentialsAsync(
uri,
proxy : null,
type : type,
message : message,
cancellationToken : cancellationToken);
NuGet.Protocol.Core.v3.HttpHandlerResourceV3.CredentialsSuccessfullyUsed = (uri, credentials) =>
{
NuGet.CredentialStore.Instance.Add(uri, credentials);
NuGet.Configuration.CredentialStore.Instance.Add(uri, credentials);
};
}
protected override async Task OnInitializedAsync()
{
Model = new StandUpModel();
HasCredentials = (await CredentialService.GetCredentialsAsync()).Any();
GenerateLabel = "Generate!";
}
protected override async Task OnInitializedAsync()
{
SavedCredentials = await CredentialService.GetCredentialsAsync();
}
public async Task GetCredentials_TriesAllProviders_EvenWhenSameType()
{
// Arrange
var mockProvider1 = new Mock <ICredentialProvider>();
mockProvider1
.Setup(x => x.GetAsync(
It.IsAny <Uri>(),
It.IsAny <IWebProxy>(),
It.IsAny <CredentialRequestType>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new CredentialResponse(CredentialStatus.ProviderNotApplicable)));
mockProvider1.Setup(x => x.Id).Returns("1");
var mockProvider2 = new Mock <ICredentialProvider>();
mockProvider2
.Setup(x => x.GetAsync(
It.IsAny <Uri>(),
It.IsAny <IWebProxy>(),
It.IsAny <CredentialRequestType>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()))
.Returns(
Task.FromResult(new CredentialResponse(CredentialStatus.ProviderNotApplicable)));
mockProvider2.Setup(x => x.Id).Returns("2");
var service = new CredentialService(
new[] { mockProvider1.Object, mockProvider2.Object },
TestableErrorWriter,
nonInteractive: false);
var uri1 = new Uri("http://host/some/path");
// Act
var result1 = await service.GetCredentialsAsync(
uri1,
proxy : null,
type : CredentialRequestType.Unauthorized,
message : null,
cancellationToken : CancellationToken.None);
// Assert
Assert.Null(result1);
mockProvider1.Verify(
x => x.GetAsync(
It.IsAny <Uri>(),
It.IsAny <IWebProxy>(),
It.IsAny <CredentialRequestType>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()),
Times.Once);
mockProvider2.Verify(
x => x.GetAsync(
It.IsAny <Uri>(),
It.IsAny <IWebProxy>(),
It.IsAny <CredentialRequestType>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()),
Times.Once);
}
private async Task DeleteCredential(Guid id)
{
await CredentialService.RemoveCredentialAsync(id);
SavedCredentials = await CredentialService.GetCredentialsAsync();
}
