public void SerializeThenDeserialize_WithValidArguments_RoundTrips(PackageSourceContextInfo expectedResult)
{
PackageSourceContextInfo?actualResult = SerializeThenDeserialize(PackageSourceContextInfoFormatter.Instance, expectedResult);
Assert.NotNull(actualResult);
Assert.Equal(expectedResult, actualResult);
}
public ValueTask <IReadOnlyList <PackageSourceContextInfo> > GetPackageSourcesAsync(CancellationToken cancellationToken)
{
return(new ValueTask <IReadOnlyList <PackageSourceContextInfo> >(
_sharedServiceState.SourceRepositoryProvider.PackageSourceProvider
.LoadPackageSources()
.Select(packageSource => PackageSourceContextInfo.Create(packageSource))
.ToList()));
}
public async Task GetCurrent_WithAnySearchResults_PreservesSearchResultsOrderAsync(string[] inputIds)
{
// Arrange
var psmContextInfos = new List <PackageSearchMetadataContextInfo>();
foreach (var id in inputIds)
{
psmContextInfos.Add(PackageSearchMetadataContextInfo.Create(new PackageSearchMetadataBuilder.ClonedPackageSearchMetadata()
{
Identity = new PackageIdentity(id, new NuGetVersion("1.0")),
}));
}
var searchResult = new SearchResultContextInfo(psmContextInfos, new Dictionary <string, LoadingStatus> {
{ "Search", LoadingStatus.Loading }
}, hasMoreItems: false);
var serviceBroker = Mock.Of <IServiceBroker>();
var packageFileService = new Mock <INuGetPackageFileService>();
var searchService = new Mock <IReconnectingNuGetSearchService>(MockBehavior.Strict);
searchService.Setup(s => s.SearchAsync(It.IsAny <IReadOnlyCollection <IProjectContextInfo> >(),
It.IsAny <IReadOnlyCollection <PackageSourceContextInfo> >(),
It.IsAny <IReadOnlyCollection <string> >(),
It.IsAny <string>(),
It.IsAny <SearchFilter>(),
It.IsAny <NuGet.VisualStudio.Internal.Contracts.ItemFilter>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()))
.Returns(new ValueTask <SearchResultContextInfo>(searchResult));
var uiContext = new Mock <INuGetUIContext>();
uiContext.Setup(ui => ui.ServiceBroker).Returns(serviceBroker);
var context = new PackageLoadContext(isSolution: false, uiContext.Object);
var mockProgress = Mock.Of <IProgress <IItemLoaderState> >();
using var localFeedDir = TestDirectory.Create(); // local feed
var localSource = new PackageSource(localFeedDir);
var loader = await PackageItemLoader.CreateAsync(
serviceBroker,
context,
new List <PackageSourceContextInfo>() { PackageSourceContextInfo.Create(localSource) },
NuGet.VisualStudio.Internal.Contracts.ItemFilter.All,
searchService.Object,
packageFileService.Object,
TestSearchTerm);
// Act
await loader.LoadNextAsync(progress : mockProgress, CancellationToken.None);
IEnumerable <PackageItemViewModel> items = loader.GetCurrent();
// Assert
string[] result = items.Select(pkg => pkg.Id).ToArray();
Assert.Equal(inputIds, result);
}
private void UpdateTextBoxes(PackageSourceContextInfo packageSource)
{
if (packageSource != null)
{
NewPackageName.Text = packageSource.Name;
NewPackageSource.Text = packageSource.Source;
}
else
{
NewPackageName.Text = string.Empty;
NewPackageSource.Text = string.Empty;
}
}
private PackageSourceContextInfo CreateNewPackageSource()
{
var sourcesList = (IEnumerable <PackageSourceContextInfo>)_packageSources.List;
for (int i = 0; ; i++)
{
var newName = i == 0 ? "Package source" : "Package source " + i;
var newSource = i == 0 ? "https://packagesource" : "https://packagesource" + i;
var packageSource = new PackageSourceContextInfo(newSource, newName);
if (sourcesList.All(ps => !ps.Equals(packageSource)))
{
return(packageSource);
}
}
}
public async Task GetPackageVersionsAsync_WhenPackageVersionsExist_ReturnsPackageVersions()
{
using (NuGetPackageSearchService searchService = SetupSearchService())
{
IReadOnlyCollection <VersionInfoContextInfo> result = await searchService.GetPackageVersionsAsync(
new PackageIdentity("microsoft.extensions.logging.abstractions", new Versioning.NuGetVersion("5.0.0-rc.2.20475.5")),
new List <PackageSourceContextInfo> {
PackageSourceContextInfo.Create(_sourceRepository.PackageSource)
},
includePrerelease : true,
CancellationToken.None);
Assert.Equal(60, result.Count);
Assert.True(result.Last().Version.Version.Equals(new Version("1.0.0.0")));
}
}
public async Task GetPackageMetadataListAsync_WithValidArguments_ReturnsMatchingResults()
{
using (NuGetPackageSearchService searchService = SetupSearchService())
{
IReadOnlyCollection <PackageSearchMetadataContextInfo> packageMetadataList = await searchService.GetPackageMetadataListAsync(
id : "NuGet.Core",
new List <PackageSourceContextInfo> {
PackageSourceContextInfo.Create(_sourceRepository.PackageSource)
},
includePrerelease : true,
includeUnlisted : true,
CancellationToken.None);
Assert.Equal(57, packageMetadataList.Count);
}
}
public async Task GetDeprecationMetadataAsync_WhenDeprecationMetadataExists_ReturnsDeprecationMetadata()
{
using (NuGetPackageSearchService searchService = SetupSearchService())
{
PackageDeprecationMetadataContextInfo deprecationMetadata = await searchService.GetDeprecationMetadataAsync(
new PackageIdentity("microsoft.extensions.logging.abstractions", new Versioning.NuGetVersion("5.0.0-rc.2.20475.5")),
new List <PackageSourceContextInfo> {
PackageSourceContextInfo.Create(_sourceRepository.PackageSource)
},
includePrerelease : true,
CancellationToken.None);
Assert.NotNull(deprecationMetadata);
Assert.Equal("This is deprecated.", deprecationMetadata.Message);
Assert.Equal("Legacy", deprecationMetadata.Reasons.First());
}
}
public async Task GetAllPackagesAsync_WithValidArguments_ReturnsMatchingPackages()
{
using (NuGetPackageSearchService searchService = SetupSearchService())
{
IReadOnlyCollection <PackageSearchMetadataContextInfo> allPackages = await searchService.GetAllPackagesAsync(
_projects,
new List <PackageSourceContextInfo> {
PackageSourceContextInfo.Create(_sourceRepository.PackageSource)
},
targetFrameworks : new List <string>()
{
"net45", "net5.0"
},
new SearchFilter(includePrerelease : true),
NuGet.VisualStudio.Internal.Contracts.ItemFilter.All,
CancellationToken.None);
Assert.Equal(1, allPackages.Count);
}
}
public async Task GetTotalCountAsync_WithLessThanMaxCountResults_ReturnsResultsCount()
{
using (NuGetPackageSearchService searchService = SetupSearchService())
{
int totalCount = await searchService.GetTotalCountAsync(
maxCount : 100,
_projects,
new List <PackageSourceContextInfo> {
PackageSourceContextInfo.Create(_sourceRepository.PackageSource)
},
targetFrameworks : new List <string>()
{
"net45", "net5.0"
},
new SearchFilter(includePrerelease : true),
NuGet.VisualStudio.Internal.Contracts.ItemFilter.All,
CancellationToken.None);
Assert.Equal(1, totalCount);
}
}
public async Task GetPackageVersionsAsync_WithProjectAndIsTransitiveAndCacheIsNotPopulatedAsync()
{
using (NuGetPackageSearchService searchService = SetupSearchService())
{
PackageIdentity transitivePackage = new PackageIdentity("microsoft.extensions.logging.abstractions", new Versioning.NuGetVersion("5.0.0-rc.2.20475.5"));
var packageSources = new List <PackageSourceContextInfo> {
PackageSourceContextInfo.Create(_sourceRepository.PackageSource)
};
var metadataProvider = Mock.Of <IPackageMetadataProvider>();
CacheItemPolicy _cacheItemPolicy = new CacheItemPolicy
{
SlidingExpiration = ObjectCache.NoSlidingExpiration,
AbsoluteExpiration = ObjectCache.InfiniteAbsoluteExpiration,
};
Mock.Get(metadataProvider)
.Setup(m => m.GetPackageMetadataAsync(It.IsAny <PackageIdentity>(), It.IsAny <bool>(), It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(PackageSearchMetadataBuilder.FromIdentity(new PackageIdentity("microsoft.extensions.logging.abstractions", NuGetVersion.Parse("5.0.0-rc.2.20475.5"))).Build()));
IPackageSearchMetadata packageMetadata = await metadataProvider.GetPackageMetadataAsync(transitivePackage, true, CancellationToken.None);
string cacheId = PackageSearchMetadataCacheItem.GetCacheId(transitivePackage.Id, true, packageSources);
var cacheEntry = new PackageSearchMetadataCacheItem(packageMetadata, metadataProvider);
NuGetPackageSearchService.PackageSearchMetadataMemoryCache.AddOrGetExisting(cacheId, cacheEntry, _cacheItemPolicy);
IReadOnlyCollection <VersionInfoContextInfo> result = await searchService.GetPackageVersionsAsync(
transitivePackage,
packageSources,
includePrerelease : true,
isTransitive : true,
_projects,
CancellationToken.None);
Assert.Equal(60, result.Count);
Assert.True(result.Last().Version.Version.Equals(new Version("1.0.0.0")));
}
}
public async Task ContinueSearchAsync_WhenSearchIsContinuable_Continues()
{
var telemetryService = new Mock <INuGetTelemetryService>();
var eventsQueue = new ConcurrentQueue <TelemetryEvent>();
telemetryService
.Setup(x => x.EmitTelemetryEvent(It.IsAny <TelemetryEvent>()))
.Callback <TelemetryEvent>(e => eventsQueue.Enqueue(e));
TelemetryActivity.NuGetTelemetryService = telemetryService.Object;
using (NuGetPackageSearchService searchService = SetupSearchService())
{
SearchResultContextInfo searchResult = await searchService.SearchAsync(
_projects,
new List <PackageSourceContextInfo> {
PackageSourceContextInfo.Create(_sourceRepository.PackageSource)
},
targetFrameworks : new List <string>()
{
"net45", "net5.0"
},
searchText : "nuget",
new SearchFilter(includePrerelease : true),
NuGet.VisualStudio.Internal.Contracts.ItemFilter.All,
useRecommender : true,
CancellationToken.None);
SearchResultContextInfo continueSearchResult = await searchService.ContinueSearchAsync(CancellationToken.None);
Assert.True(searchResult.PackageSearchItems.First().Title.Equals("NuGet.Core1", StringComparison.OrdinalIgnoreCase));
Assert.True(continueSearchResult.PackageSearchItems.First().Title.Equals("NuGet.Core27", StringComparison.OrdinalIgnoreCase));
TelemetryEvent[] events = eventsQueue.ToArray();
Assert.True(4 == events.Length, string.Join(Environment.NewLine, events.Select(e => e.Name)));
TelemetryEvent search = Assert.Single(events, e => e.Name == "Search");
Assert.Equal(true, search["IncludePrerelease"]);
Assert.Equal("nuget", search.GetPiiData().First(p => p.Key == "Query").Value);
string operationId = Assert.IsType <string>(search["OperationId"]);
Guid parsedOperationId = Guid.ParseExact(operationId, "D");
TelemetryEvent sources = Assert.Single(events, e => e.Name == "SearchPackageSourceSummary");
Assert.Equal(1, sources["NumHTTPv3Feeds"]);
Assert.Equal("NotPresent", sources["NuGetOrg"]);
Assert.Equal(operationId, sources["ParentId"]);
TelemetryEvent page0 = Assert.Single(events, e => e.Name == "SearchPage" && e["PageIndex"] is int && (int)e["PageIndex"] == 0);
Assert.Equal("Ready", page0["LoadingStatus"]);
Assert.Equal(operationId, page0["ParentId"]);
Assert.IsType <int>(page0["ResultCount"]);
Assert.IsType <double>(page0["Duration"]);
Assert.IsType <double>(page0["ResultsAggregationDuration"]);
Assert.IsType <string>(page0["IndividualSourceDurations"]);
Assert.Equal(1, ((JArray)JsonConvert.DeserializeObject((string)page0["IndividualSourceDurations"])).Values <double>().Count());
TelemetryEvent page1 = Assert.Single(events, e => e.Name == "SearchPage" && e["PageIndex"] is int && (int)e["PageIndex"] == 1);
Assert.Equal("Ready", page1["LoadingStatus"]);
Assert.Equal(operationId, page1["ParentId"]);
Assert.IsType <int>(page1["ResultCount"]);
Assert.IsType <double>(page1["Duration"]);
Assert.IsType <double>(page1["ResultsAggregationDuration"]);
Assert.IsType <string>(page1["IndividualSourceDurations"]);
Assert.Equal(1, ((JArray)JsonConvert.DeserializeObject((string)page1["IndividualSourceDurations"])).Values <double>().Count());
}
}
private static void CopySelectedItem(PackageSourceContextInfo selectedPackageSource)
{
Clipboard.Clear();
Clipboard.SetText(selectedPackageSource.Source);
}
public async Task MultipleSourcesPrefixReserved_Works()
{
var solutionManager = Mock.Of <INuGetSolutionManagerService>();
var uiContext = new Mock <INuGetUIContext>();
var searchService = new Mock <INuGetSearchService>(MockBehavior.Strict);
var packageSearchMetadata = new PackageSearchMetadataBuilder.ClonedPackageSearchMetadata()
{
Identity = new PackageIdentity("NuGet.org", new NuGetVersion("1.0")),
PrefixReserved = true
};
var packageSearchMetadataContextInfo = new List <PackageSearchMetadataContextInfo>()
{
PackageSearchMetadataContextInfo.Create(packageSearchMetadata)
};
var searchResult = new SearchResultContextInfo(packageSearchMetadataContextInfo, new Dictionary <string, LoadingStatus> {
{ "Completed", LoadingStatus.Ready }
}, false);
searchService.Setup(x =>
x.SearchAsync(
It.IsAny <IReadOnlyCollection <IProjectContextInfo> >(),
It.IsAny <IReadOnlyCollection <PackageSourceContextInfo> >(),
It.IsAny <IReadOnlyCollection <string> >(),
It.IsAny <string>(),
It.IsAny <SearchFilter>(),
It.IsAny <NuGet.VisualStudio.Internal.Contracts.ItemFilter>(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()))
.Returns(new ValueTask <SearchResultContextInfo>(searchResult));
searchService.Setup(x =>
x.RefreshSearchAsync(It.IsAny <CancellationToken>()))
.Returns(new ValueTask <SearchResultContextInfo>(searchResult));
uiContext.Setup(x => x.SolutionManagerService)
.Returns(solutionManager);
uiContext.Setup(x => x.ServiceBroker)
.Returns(Mock.Of <IServiceBroker>());
var source1 = new PackageSourceContextInfo("https://pkgs.dev.azure.com/dnceng/public/_packaging/nuget-build/nuget/v3/index.json", "NuGetBuild");
var source2 = new PackageSourceContextInfo("https://api.nuget.org/v3/index.json", "NuGet.org");
var context = new PackageLoadContext(false, uiContext.Object);
var loader = await PackageItemLoader.CreateAsync(
Mock.Of <IServiceBroker>(),
context,
new List <PackageSourceContextInfo> {
source1, source2
},
NuGet.VisualStudio.Internal.Contracts.ItemFilter.All,
searchService.Object,
TestSearchTerm);
await loader.LoadNextAsync(null, CancellationToken.None);
var items = loader.GetCurrent();
Assert.NotEmpty(items);
// All items should not have a prefix reserved because the feed is multisource
foreach (var item in items)
{
Assert.False(item.PrefixReserved);
}
}
public async Task PackageReader_NotNull()
{
// Prepare
var solutionManager = Mock.Of <INuGetSolutionManagerService>();
var uiContext = new Mock <INuGetUIContext>();
uiContext.Setup(x => x.SolutionManagerService)
.Returns(solutionManager);
var searchService = new Mock <INuGetSearchService>(MockBehavior.Strict);
var packageSearchMetadata = new PackageSearchMetadataBuilder.ClonedPackageSearchMetadata()
{
Identity = new PackageIdentity("NuGet.org", new NuGetVersion("1.0")),
PrefixReserved = true
};
var packageSearchMetadataContextInfo = new List <PackageSearchMetadataContextInfo>()
{
PackageSearchMetadataContextInfo.Create(packageSearchMetadata)
};
var searchResult = new SearchResultContextInfo(packageSearchMetadataContextInfo, new Dictionary <string, LoadingStatus> {
{ "Search", LoadingStatus.Loading }
}, false);
searchService.Setup(x =>
x.SearchAsync(
It.IsAny <IReadOnlyCollection <IProjectContextInfo> >(),
It.IsAny <IReadOnlyCollection <PackageSourceContextInfo> >(),
It.IsAny <IReadOnlyCollection <string> >(),
It.IsAny <string>(),
It.IsAny <SearchFilter>(),
It.IsAny <NuGet.VisualStudio.Internal.Contracts.ItemFilter>(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()))
.Returns(new ValueTask <SearchResultContextInfo>(searchResult));
uiContext.Setup(x => x.ServiceBroker)
.Returns(Mock.Of <IServiceBroker>());
using (var localFeedDir = TestDirectory.Create()) // local feed
{
// create test package
var pkgId = new PackageIdentity("nuget.lpsm.test", new NuGetVersion(0, 0, 1));
var pkg = new SimpleTestPackageContext(pkgId.Id, pkgId.Version.ToNormalizedString());
await SimpleTestPackageUtility.CreatePackagesAsync(localFeedDir.Path, pkg);
// local test source
var localUri = new Uri(localFeedDir.Path, UriKind.Absolute);
var localSource = new PackageSource(localUri.ToString(), "LocalSource");
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { localSource });
var repositories = sourceRepositoryProvider.GetRepositories();
var context = new PackageLoadContext(isSolution: false, uiContext.Object);
var packageFeed = new MultiSourcePackageFeed(repositories, logger: null, telemetryService: null);
var loader = await PackageItemLoader.CreateAsync(
Mock.Of <IServiceBroker>(),
context,
new List <PackageSourceContextInfo> {
PackageSourceContextInfo.Create(localSource)
},
NuGet.VisualStudio.Internal.Contracts.ItemFilter.All,
searchService.Object,
TestSearchTerm);
// Act
await loader.LoadNextAsync(progress : null, CancellationToken.None);
var results = loader.GetCurrent();
// Assert
Assert.Single(results);
Assert.NotNull(results.First().PackageReader);
}
}
private static string GetTooltip(PackageSourceContextInfo packageSource)
{
return(string.IsNullOrEmpty(packageSource.Description)
? $"{packageSource.Name} - {packageSource.Source}"
: $"{packageSource.Name} - {packageSource.Description} - {packageSource.Source}");
}
public async Task PackagePrefixReservation_FromMultiSource()
{
var solutionManager = Mock.Of <INuGetSolutionManagerService>();
var uiContext = new Mock <INuGetUIContext>();
var searchService = Mock.Of <INuGetSearchService>();
var packageFileService = Mock.Of <INuGetPackageFileService>();
uiContext.Setup(x => x.SolutionManagerService)
.Returns(solutionManager);
uiContext.Setup(x => x.ServiceBroker)
.Returns(Mock.Of <IServiceBroker>());
// Arrange
var responses = new Dictionary <string, string>
{
{
"https://api-v3search-0.nuget.org/query?q=EntityFramework&skip=0&take=26&prerelease=false&semVerLevel=2.0.0",
ProtocolUtility.GetResource("NuGet.PackageManagement.UI.Test.compiler.resources.EntityFrameworkSearch.json", GetType())
},
{ "http://testsource.com/v3/index.json", JsonData.IndexWithoutFlatContainer },
{ "http://othersource.com/v3/index.json", JsonData.IndexWithoutFlatContainer }
};
var repo = StaticHttpHandler.CreateSource("http://testsource.com/v3/index.json", Repository.Provider.GetCoreV3(), responses);
var repo1 = StaticHttpHandler.CreateSource("http://othersource.com/v3/index.json", Repository.Provider.GetCoreV3(), responses);
var context = new PackageLoadContext(isSolution: false, uiContext.Object);
var loader = await PackageItemLoader.CreateAsync(
Mock.Of <IServiceBroker>(),
context,
new List <PackageSourceContextInfo>
{
PackageSourceContextInfo.Create(repo.PackageSource),
PackageSourceContextInfo.Create(repo1.PackageSource)
},
NuGet.VisualStudio.Internal.Contracts.ItemFilter.All,
searchService,
packageFileService,
"EntityFramework",
includePrerelease : false);
var packageSearchMetadata = new PackageSearchMetadataBuilder.ClonedPackageSearchMetadata()
{
Identity = new PackageIdentity("NuGet.org", new NuGetVersion("1.0")),
PrefixReserved = true
};
var packageSearchMetadataContextInfo = new List <PackageSearchMetadataContextInfo>()
{
PackageSearchMetadataContextInfo.Create(packageSearchMetadata)
};
var searchResult = new SearchResultContextInfo(
packageSearchMetadataContextInfo,
new Dictionary <string, LoadingStatus> {
{ "Completed", LoadingStatus.Ready }
},
hasMoreItems: false);
await loader.UpdateStateAndReportAsync(searchResult, progress : null, CancellationToken.None);
var items = loader.GetCurrent();
// Resource only has one item
var item = items.First();
// Assert that a multisource always has prefixreserved set to false
Assert.False(item.PrefixReserved);
}
public async Task GetTotalCountAsync_WithGreaterThanOrEqualToMaxCountResults_ReturnsMaxCount()
{
var source1 = new PackageSource("https://dotnet.myget.org/F/nuget-volatile/api/v3/index.json", "NuGetVolatile");
var source2 = new PackageSource("https://api.nuget.org/v3/index.json", "NuGet.org");
var sources = new List <PackageSource> {
source1, source2
};
var sourceRepository = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { source1, source2 });
var solutionManager = new Mock <IVsSolutionManager>();
solutionManager.SetupGet(x => x.SolutionDirectory).Returns("z:\\SomeRandomPath");
var settings = new Mock <ISettings>();
var deleteOnRestartManager = new Mock <IDeleteOnRestartManager>();
AddService <IDeleteOnRestartManager>(Task.FromResult <object>(deleteOnRestartManager.Object));
AddService <IVsSolutionManager>(Task.FromResult <object>(solutionManager.Object));
AddService <ISettings>(Task.FromResult <object>(settings.Object));
AddService <ISourceRepositoryProvider>(Task.FromResult <object>(sourceRepository));
var serviceActivationOptions = default(ServiceActivationOptions);
var serviceBroker = new Mock <IServiceBroker>();
var authorizationService = new AuthorizationServiceClient(Mock.Of <IAuthorizationService>());
var sharedState = new SharedServiceState(sourceRepository);
var projectManagerService = new Mock <INuGetProjectManagerService>();
var installedPackages = new List <IPackageReferenceContextInfo>();
var projects = new List <IProjectContextInfo>
{
new ProjectContextInfo(
Guid.NewGuid().ToString(),
ProjectModel.ProjectStyle.PackageReference,
NuGetProjectKind.PackageReference)
};
projectManagerService.Setup(x => x.GetInstalledPackagesAsync(
It.IsAny <IReadOnlyCollection <string> >(),
It.IsAny <CancellationToken>()))
.Returns(new ValueTask <IReadOnlyCollection <IPackageReferenceContextInfo> >(installedPackages));
#pragma warning disable ISB001 // Dispose of proxies
serviceBroker.Setup(x => x.GetProxyAsync <INuGetProjectManagerService>(
NuGetServices.ProjectManagerService,
It.IsAny <ServiceActivationOptions>(),
It.IsAny <CancellationToken>()))
.Returns(new ValueTask <INuGetProjectManagerService>(projectManagerService.Object));
#pragma warning restore ISB001 // Dispose of proxies
using (var searchService = new NuGetPackageSearchService(
serviceActivationOptions,
serviceBroker.Object,
authorizationService,
sharedState))
{
const int MaxCount = 100;
int totalCount = await searchService.GetTotalCountAsync(
MaxCount,
projects,
sources.Select(s => PackageSourceContextInfo.Create(s)).ToList(),
targetFrameworks : new List <string>()
{
"net45", "net5.0"
},
new SearchFilter(includePrerelease : true),
NuGet.VisualStudio.Internal.Contracts.ItemFilter.All,
CancellationToken.None);
Assert.Equal(MaxCount, totalCount);
}
}
private void PackageSourceProvider_PackageSourcesChanged(object sender, EventArgs e)
{
List <PackageSourceContextInfo> packageSources = _sharedServiceState.SourceRepositoryProvider.PackageSourceProvider.LoadPackageSources().Select(packageSource => PackageSourceContextInfo.Create(packageSource)).ToList();
PackageSourcesChanged?.Invoke(this, packageSources);
}
