public async Task Object_NoAvailabilityChanges_WrapsInstanceFromServiceBroker()
{
// Arrange
Mock <INuGetSearchService> searchService = new();
Mock <IServiceBroker> serviceBroker = new();
serviceBroker.Setup(sb =>
#pragma warning disable ISB001 // Dispose of proxies
sb.GetProxyAsync <INuGetSearchService>(It.IsAny <ServiceJsonRpcDescriptor>(), It.IsAny <ServiceActivationOptions>(), It.IsAny <CancellationToken>())
#pragma warning restore ISB001 // Dispose of proxies
)
.ReturnsAsync(searchService.Object);
NuGetSearchServiceReconnector target = await NuGetSearchServiceReconnector.CreateAsync(serviceBroker.Object, _jtf, CancellationToken.None);
CancellationToken cancellationToken = new();
// Act
// searchService.Object is an instance of ManagedNuGetSearchService, not the mocked object above. Hence, we need to call
// a method on the managed wrapper, to ensure that it correctly calls the instance from the IServiceBroker.
await target.Object.ContinueSearchAsync(cancellationToken);
// Assert
searchService.Verify(s => s.ContinueSearchAsync(cancellationToken), Times.Once);
}
public async Task CreateAsync_NullArguments_ThrowsArgumentNullException()
{
// Arrange
Mock <IServiceBroker> serviceBroker = new();
// Act & Assert
ArgumentNullException exception = await Assert.ThrowsAsync <ArgumentNullException>(() => NuGetSearchServiceReconnector.CreateAsync(serviceBroker: null, _jtf, CancellationToken.None));
Assert.Equal("serviceBroker", exception.ParamName);
exception = await Assert.ThrowsAsync <ArgumentNullException>(() => NuGetSearchServiceReconnector.CreateAsync(serviceBroker.Object, jtf: null, CancellationToken.None));
Assert.Equal("jtf", exception.ParamName);
}
public async Task AvailabilityChangedAsync_OnChange_GetsNewInstanceFromServiceBroker()
{
// Arrange
Mock <INuGetSearchService> searchService1 = new();
Mock <INuGetSearchService> searchService2 = new();
int getProxyCount = 0;
Mock <IServiceBroker> serviceBroker = new();
serviceBroker.Setup(sb =>
#pragma warning disable ISB001 // Dispose of proxies
sb.GetProxyAsync <INuGetSearchService>(It.IsAny <ServiceJsonRpcDescriptor>(), It.IsAny <ServiceActivationOptions>(), It.IsAny <CancellationToken>())
#pragma warning restore ISB001 // Dispose of proxies
)
.ReturnsAsync(() =>
{
int count = Interlocked.Increment(ref getProxyCount);
switch (count)
{
case 1:
return(searchService1.Object);
case 2:
return(searchService2.Object);
default:
throw new InvalidOperationException();
}
});
// Act
NuGetSearchServiceReconnector target = await NuGetSearchServiceReconnector.CreateAsync(serviceBroker.Object, _jtf, CancellationToken.None);
await target.AvailabilityChangedAsync();
await target.Object.ContinueSearchAsync(CancellationToken.None);
// Assert
searchService1.Verify(s => s.ContinueSearchAsync(It.IsAny <CancellationToken>()), Times.Never);
searchService1.Verify(s => s.Dispose(), Times.Once);
searchService2.Verify(s => s.ContinueSearchAsync(It.IsAny <CancellationToken>()), Times.Once);
searchService2.Verify(s => s.Dispose(), Times.Never);
}
public async Task Dispose_DisposeInnerService_DoesNotDisposedBrokeredService()
{
// Arrange
Mock <INuGetSearchService> searchService = new();
Mock <IServiceBroker> serviceBroker = new();
serviceBroker.Setup(sb =>
#pragma warning disable ISB001 // Dispose of proxies
sb.GetProxyAsync <INuGetSearchService>(It.IsAny <ServiceJsonRpcDescriptor>(), It.IsAny <ServiceActivationOptions>(), It.IsAny <CancellationToken>())
#pragma warning restore ISB001 // Dispose of proxies
)
.ReturnsAsync(searchService.Object);
NuGetSearchServiceReconnector target = await NuGetSearchServiceReconnector.CreateAsync(serviceBroker.Object, _jtf, CancellationToken.None);
// Act
target.Object.Dispose();
// Assert
searchService.Verify(s => s.Dispose(), Times.Never);
}
public static async ValueTask <NuGetUIContext> CreateAsync(
IServiceBroker serviceBroker,
ISourceRepositoryProvider sourceRepositoryProvider,
ISettings settings,
IVsSolutionManager solutionManager,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IUserSettingsManager userSettingsManager,
IDeleteOnRestartManager deleteOnRestartManager,
IEnumerable <IVsPackageManagerProvider> packageManagerProviders,
INuGetLockService lockService,
CancellationToken cancellationToken)
{
Assumes.NotNull(serviceBroker);
Assumes.NotNull(sourceRepositoryProvider);
Assumes.NotNull(settings);
Assumes.NotNull(solutionManager);
Assumes.NotNull(packageRestoreManager);
Assumes.NotNull(optionsPageActivator);
Assumes.NotNull(userSettingsManager);
Assumes.NotNull(deleteOnRestartManager);
Assumes.NotNull(packageManagerProviders);
Assumes.NotNull(lockService);
cancellationToken.ThrowIfCancellationRequested();
var solutionManagerServiceWrapper = new NuGetSolutionManagerServiceWrapper();
INuGetSolutionManagerService solutionManagerService = await GetSolutionManagerServiceAsync(serviceBroker, cancellationToken);
// The initial Swap(...) should return a null implementation of the interface that does not require disposal.
// However, there's no harm in following form.
using (solutionManagerServiceWrapper.Swap(solutionManagerService))
{
}
var sourceServiceWrapper = new NuGetSourcesServiceWrapper();
INuGetSourcesService sourceService = await GetSourceServiceAsync(serviceBroker, cancellationToken);
using (sourceServiceWrapper.Swap(sourceService))
{
}
#pragma warning disable CA2000 // Dispose objects before losing scope - NuGetUIContext owns the instance and should dispose it.
var searchService = await NuGetSearchServiceReconnector.CreateAsync(serviceBroker, NuGetUIThreadHelper.JoinableTaskFactory, cancellationToken);
#pragma warning restore CA2000 // Dispose objects before losing scope
var packageManager = new NuGetPackageManager(
sourceRepositoryProvider,
settings,
solutionManager,
deleteOnRestartManager);
var actionEngine = new UIActionEngine(
sourceRepositoryProvider,
packageManager,
lockService);
return(new NuGetUIContext(
serviceBroker,
searchService.Object,
solutionManager,
solutionManagerServiceWrapper,
packageManager,
actionEngine,
packageRestoreManager,
optionsPageActivator,
userSettingsManager,
packageManagerProviders,
sourceServiceWrapper));
}
