protected void RemoveLanguageResource(PluginItemRegistration itemRegistration)
{
PluginResource languageResource = (PluginResource)itemRegistration.Item;
lock (_syncObj)
_languageDirectories.Remove(languageResource.Path);
ReLoad();
}
public async Task GetPluginAsync_ThrowsIfCancelled()
{
var resource = new PluginResource(
Enumerable.Empty <PluginCreationResult>(),
_packageSource,
Mock.Of <ICredentialService>());
await Assert.ThrowsAsync <OperationCanceledException>(
() => resource.GetPluginAsync(OperationClaim.DownloadPackage, new CancellationToken(canceled: true)));
}
public async Task GetPluginAsync_ReturnsNullIfNoPlugins()
{
var resource = new PluginResource(
Enumerable.Empty <PluginCreationResult>(),
_packageSource,
Mock.Of <ICredentialService>());
var result = await resource.GetPluginAsync(OperationClaim.DownloadPackage, CancellationToken.None);
Assert.Null(result);
}
public async Task GetPluginAsync_ReturnsNullIfNoPluginWithMatchingOperationClaim()
{
var resource = new PluginResource(
new[] { new PluginCreationResult(
Mock.Of <IPlugin>(),
Mock.Of <IPluginMulticlientUtilities>(),
new[] { OperationClaim.DownloadPackage }) },
_packageSource,
Mock.Of <ICredentialService>());
var result = await resource.GetPluginAsync((OperationClaim)int.MaxValue, CancellationToken.None);
Assert.Null(result);
}
private static PluginResourceProvider CreatePluginResourceProvider(bool createResource)
{
var provider = new Mock <PluginResourceProvider>();
provider.Setup(x => x.Name)
.Returns(nameof(PluginResourceProvider));
provider.Setup(x => x.ResourceType)
.Returns(typeof(PluginResource));
PluginResource pluginResource = null;
if (createResource)
{
var plugin = new Mock <IPlugin>();
var utilities = new Mock <IPluginMulticlientUtilities>();
var connection = new Mock <IConnection>();
var dispatcher = new Mock <IMessageDispatcher>();
dispatcher.SetupGet(x => x.RequestHandlers)
.Returns(new RequestHandlers());
connection.SetupGet(x => x.MessageDispatcher)
.Returns(dispatcher.Object);
plugin.Setup(x => x.Connection)
.Returns(connection.Object);
var creationResult = new PluginCreationResult(
plugin.Object,
utilities.Object,
new List <OperationClaim>()
{
OperationClaim.DownloadPackage
});
var packageSource = new PackageSource(source: "https://unit.test");
pluginResource = new PluginResource(
new[] { creationResult },
packageSource,
Mock.Of <ICredentialService>());
}
var tryCreateResult = new Tuple <bool, INuGetResource>(pluginResource != null, pluginResource);
provider.Setup(x => x.TryCreate(It.IsAny <SourceRepository>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(tryCreateResult));
return(provider.Object);
}
public async Task GetPluginAsync_ReturnsFirstPluginWithMatchingOperationClaim()
{
var plugin = new Mock <IPlugin>(MockBehavior.Strict);
var utilities = new Mock <IPluginMulticlientUtilities>(MockBehavior.Strict);
var connection = new Mock <IConnection>(MockBehavior.Strict);
connection.Setup(x => x.SendRequestAndReceiveResponseAsync <SetCredentialsRequest, SetCredentialsResponse>(
It.Is <MessageMethod>(m => m == MessageMethod.SetCredentials),
It.Is <SetCredentialsRequest>(s => s.PackageSourceRepository == _packageSource.Source &&
s.ProxyUsername == null && s.ProxyPassword == null &&
s.Username == null && s.Password == null),
It.IsAny <CancellationToken>()))
.ReturnsAsync(new SetCredentialsResponse(MessageResponseCode.Success));
plugin.SetupGet(x => x.Connection)
.Returns(connection.Object);
utilities.Setup(x => x.DoOncePerPluginLifetimeAsync(
It.IsNotNull <string>(),
It.IsNotNull <Func <Task> >(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(0));
var pluginCreationResults = new List <PluginCreationResult>()
{
new PluginCreationResult(
plugin.Object,
utilities.Object,
new[] { OperationClaim.DownloadPackage }),
new PluginCreationResult(
Mock.Of <IPlugin>(),
Mock.Of <IPluginMulticlientUtilities>(),
new[] { OperationClaim.DownloadPackage })
};
var resource = new PluginResource(
pluginCreationResults,
_packageSource,
credentialService: null);
var result = await resource.GetPluginAsync(OperationClaim.DownloadPackage, CancellationToken.None);
Assert.Same(pluginCreationResults[0].Plugin, result.Plugin);
Assert.Same(pluginCreationResults[0].PluginMulticlientUtilities, result.PluginMulticlientUtilities);
connection.Verify();
plugin.Verify();
utilities.Verify();
}
public async Task GetPluginAsync_ThrowsIfFirstPluginDiscoveryFailed()
{
var pluginCreationResults = new List <PluginCreationResult>()
{
new PluginCreationResult(message: "test"),
new PluginCreationResult(
Mock.Of <IPlugin>(),
Mock.Of <IPluginMulticlientUtilities>(),
new[] { OperationClaim.DownloadPackage })
};
var resource = new PluginResource(
pluginCreationResults,
_packageSource,
Mock.Of <ICredentialService>());
var exception = await Assert.ThrowsAsync <PluginException>(
() => resource.GetPluginAsync(OperationClaim.DownloadPackage, CancellationToken.None));
Assert.Equal("test", exception.Message);
}
protected void AddLanguageResources(ICollection <PluginItemMetadata> items)
{
lock (_syncObj)
foreach (PluginItemMetadata itemMetadata in items)
{
try
{
PluginResource resource = ServiceRegistration.Get <IPluginManager>().RequestPluginItem <PluginResource>(
itemMetadata.RegistrationLocation, itemMetadata.Id, _languagePluginStateTracker);
if (resource != null && Directory.Exists(resource.Path))
{
_languageDirectories.Add(resource.Path);
}
}
catch (PluginInvalidStateException e)
{
ServiceRegistration.Get <ILogger>().Warn("Cannot add language resource for {0}", e, itemMetadata);
}
}
ReLoad();
}
public async Task GetPluginAsync_SendsLastKnownGoodCredentialsFromCredentialsCache()
{
var plugin = new Mock <IPlugin>(MockBehavior.Strict);
var utilities = new Mock <IPluginMulticlientUtilities>(MockBehavior.Strict);
var connection = new Mock <IConnection>(MockBehavior.Strict);
var credentialService = new Mock <ICredentialService>(MockBehavior.Strict);
var proxyCredentials = new NetworkCredential(userName: "******", password: "******");
ICredentials proxyCredentialsOutResult = proxyCredentials;
var packageSourceCredentials = new NetworkCredential(userName: "******", password: "******");
ICredentials packageSourceCredentialsOutResult = packageSourceCredentials;
credentialService.Setup(x => x.TryGetLastKnownGoodCredentialsFromCache(
It.Is <Uri>(u => u == _packageSource.SourceUri),
It.Is <bool>(i => i),
out proxyCredentialsOutResult))
.Returns(true);
credentialService.Setup(x => x.TryGetLastKnownGoodCredentialsFromCache(
It.Is <Uri>(u => u == _packageSource.SourceUri),
It.Is <bool>(i => !i),
out packageSourceCredentialsOutResult))
.Returns(true);
connection.Setup(x => x.SendRequestAndReceiveResponseAsync <SetCredentialsRequest, SetCredentialsResponse>(
It.Is <MessageMethod>(m => m == MessageMethod.SetCredentials),
It.Is <SetCredentialsRequest>(s => s.PackageSourceRepository == _packageSource.Source &&
s.ProxyUsername == proxyCredentials.UserName &&
s.ProxyPassword == proxyCredentials.Password &&
s.Username == packageSourceCredentials.UserName &&
s.Password == packageSourceCredentials.Password),
It.IsAny <CancellationToken>()))
.ReturnsAsync(new SetCredentialsResponse(MessageResponseCode.Success));
plugin.SetupGet(x => x.Connection)
.Returns(connection.Object);
utilities.Setup(x => x.DoOncePerPluginLifetimeAsync(
It.IsNotNull <string>(),
It.IsNotNull <Func <Task> >(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(0));
var pluginCreationResults = new List <PluginCreationResult>()
{
new PluginCreationResult(
plugin.Object,
utilities.Object,
new[] { OperationClaim.DownloadPackage }),
};
var resource = new PluginResource(
pluginCreationResults,
_packageSource,
credentialService.Object);
var result = await resource.GetPluginAsync(OperationClaim.DownloadPackage, CancellationToken.None);
Assert.Same(pluginCreationResults[0].Plugin, result.Plugin);
Assert.Same(pluginCreationResults[0].PluginMulticlientUtilities, result.PluginMulticlientUtilities);
connection.Verify();
plugin.Verify();
utilities.Verify();
credentialService.Verify();
}
