public PackageItemViewModelTests(
GlobalServiceProvider globalServiceProvider,
ITestOutputHelper output,
LocalPackageSearchMetadataFixture testData)
: base(globalServiceProvider)
{
globalServiceProvider.Reset();
_serviceBroker.Setup(
#pragma warning disable ISB001 // Dispose of proxies
x => x.GetProxyAsync <INuGetPackageFileService>(
It.Is <ServiceJsonRpcDescriptor>(d => d.Moniker == NuGetServices.PackageFileService.Moniker),
It.IsAny <ServiceActivationOptions>(),
It.IsAny <CancellationToken>()))
#pragma warning restore ISB001 // Dispose of proxies
.Returns(new ValueTask <INuGetPackageFileService>(new NuGetPackageFileService(_serviceBroker.Object, _telemetryProvider.Object)));
_packageFileService = new NuGetPackageFileService(_serviceBroker.Object, _telemetryProvider.Object);
_testData = testData;
_testInstance = new PackageItemViewModel()
{
PackagePath = _testData.TestData.PackagePath,
PackageFileService = _packageFileService,
};
_output = output;
}
// For unit testing purposes
internal static async ValueTask <PackageItemLoader> CreateAsync(
IServiceBroker serviceBroker,
PackageLoadContext context,
IReadOnlyCollection <PackageSourceContextInfo> packageSources,
ContractItemFilter itemFilter,
IReconnectingNuGetSearchService searchService,
INuGetPackageFileService packageFileService,
string searchText = null,
bool includePrerelease = true,
bool useRecommender = false)
{
var itemLoader = new PackageItemLoader(
serviceBroker,
searchService,
context,
packageSources,
itemFilter,
searchText,
includePrerelease,
useRecommender);
await itemLoader.InitializeAsync(packageFileService);
return(itemLoader);
}
public static async Task <string> GetEmbeddedLicenseAsync(PackageIdentity packageIdentity, CancellationToken cancellationToken)
{
string content = null;
IServiceBrokerProvider serviceBrokerProvider = await ServiceLocator.GetInstanceAsync <IServiceBrokerProvider>();
IServiceBroker serviceBroker = await serviceBrokerProvider.GetAsync();
using (INuGetPackageFileService packageFileService = await serviceBroker.GetProxyAsync <INuGetPackageFileService>(NuGetServices.PackageFileService))
{
if (packageFileService != null)
{
using (Stream stream = await packageFileService.GetEmbeddedLicenseAsync(packageIdentity, CancellationToken.None))
{
if (stream != null)
{
using (var reader = new StreamReader(stream))
{
content = reader.ReadToEnd();
}
}
}
}
}
return(content);
}
private void OnAvailabilityChanged(object sender, BrokeredServicesChangedEventArgs e)
{
NuGetUIThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
_packageFileService?.Dispose();
_packageFileService = await GetPackageFileServiceAsync(CancellationToken.None);
}).PostOnFailure(nameof(PackageItemLoader), nameof(OnAvailabilityChanged));
}
private async ValueTask <INuGetPackageFileService> GetPackageFileServiceAsync(CancellationToken cancellationToken)
{
#pragma warning disable ISB001 // Dispose of proxies
INuGetPackageFileService packageFileService = await _serviceBroker.GetProxyAsync <INuGetPackageFileService>(NuGetServices.PackageFileService, cancellationToken);
#pragma warning restore ISB001 // Dispose of proxies
Assumes.NotNull(packageFileService);
return(packageFileService);
}
private async ValueTask InitializeAsync(INuGetPackageFileService packageFileService = null)
{
_searchFilter = new SearchFilter(includePrerelease: _includePrerelease)
{
SupportedFrameworks = await _context.GetSupportedFrameworksAsync()
};
_packageFileService = packageFileService ?? await GetPackageFileServiceAsync(CancellationToken.None);
_serviceBroker.AvailabilityChanged += OnAvailabilityChanged;
}
