public void SerializeThenDeserialize_WithValidArguments_RoundTrips(PackageSearchMetadataContextInfo expectedResult)
{
var formatters = new IMessagePackFormatter[]
{
PackageDependencyFormatter.Instance,
PackageDependencyGroupFormatter.Instance,
PackageVulnerabilityMetadataContextInfoFormatter.Instance,
};
var resolvers = new IFormatterResolver[] { MessagePackSerializerOptions.Standard.Resolver };
var options = MessagePackSerializerOptions.Standard.WithSecurity(MessagePackSecurity.UntrustedData).WithResolver(CompositeResolver.Create(formatters, resolvers));
PackageSearchMetadataContextInfo actualResult = SerializeThenDeserialize(PackageSearchMetadataContextInfoFormatter.Instance, expectedResult, options);
Assert.Equal(expectedResult.Identity, actualResult.Identity);
Assert.Equal(expectedResult.DependencySets, actualResult.DependencySets);
Assert.Equal(expectedResult.Description, actualResult.Description);
Assert.Equal(expectedResult.DownloadCount, actualResult.DownloadCount);
Assert.Equal(expectedResult.IconUrl, actualResult.IconUrl);
Assert.Equal(expectedResult.IsListed, actualResult.IsListed);
Assert.Equal(expectedResult.RecommenderVersion, actualResult.RecommenderVersion);
Assert.Equal(expectedResult.IsRecommended, actualResult.IsRecommended);
Assert.Equal(expectedResult.LicenseUrl, actualResult.LicenseUrl);
Assert.Equal(expectedResult.RequireLicenseAcceptance, actualResult.RequireLicenseAcceptance);
Assert.Equal(expectedResult.Summary, actualResult.Summary);
Assert.Equal(expectedResult.Tags, actualResult.Tags);
Assert.Equal(expectedResult.Authors, actualResult.Authors);
Assert.Equal(expectedResult.Owners, actualResult.Owners);
Assert.Equal(expectedResult.PackageDetailsUrl, actualResult.PackageDetailsUrl);
Assert.Equal(expectedResult.PrefixReserved, actualResult.PrefixReserved);
Assert.Equal(expectedResult.ProjectUrl, actualResult.ProjectUrl);
Assert.Equal(expectedResult.Published, actualResult.Published);
Assert.Equal(expectedResult.ReportAbuseUrl, actualResult.ReportAbuseUrl);
Assert.Equal(expectedResult.Title, actualResult.Title);
Assert.Equal(expectedResult.Vulnerabilities, actualResult.Vulnerabilities);
}
public async ValueTask <SearchResultContextInfo> ContinueSearchAsync(CancellationToken cancellationToken)
{
Assumes.NotNull(_lastMainFeedSearchResult);
Assumes.NotNull(_lastSearchFilter);
if (_lastMainFeedSearchResult.NextToken == null)
{
return(new SearchResultContextInfo(_lastMainFeedSearchResult.OperationId));
}
SearchResult <IPackageSearchMetadata> continueSearchResult = await _mainFeed.ContinueSearchAsync(
_lastMainFeedSearchResult.NextToken,
cancellationToken);
_lastMainFeedSearchResult = continueSearchResult;
var packageItems = new List <PackageSearchMetadataContextInfo>(_lastMainFeedSearchResult.Items.Count);
foreach (IPackageSearchMetadata packageSearchMetadata in _lastMainFeedSearchResult.Items)
{
CacheBackgroundData(packageSearchMetadata, _lastSearchFilter.IncludePrerelease);
packageItems.Add(PackageSearchMetadataContextInfo.Create(packageSearchMetadata));
}
return(new SearchResultContextInfo(
packageItems,
continueSearchResult.SourceSearchStatus.ToImmutableDictionary(),
continueSearchResult.NextToken != null,
_lastMainFeedSearchResult.OperationId));
}
public async ValueTask<(PackageSearchMetadataContextInfo, PackageDeprecationMetadataContextInfo?)> GetPackageMetadataAsync(
PackageIdentity identity,
IReadOnlyCollection<PackageSourceContextInfo> packageSources,
bool includePrerelease,
CancellationToken cancellationToken)
{
Assumes.NotNull(identity);
Assumes.NotNullOrEmpty(packageSources);
string cacheId = PackageSearchMetadataCacheItem.GetCacheId(identity.Id, includePrerelease, packageSources);
if (PackageSearchMetadataMemoryCache.Get(cacheId) is PackageSearchMetadataCacheItem backgroundDataCache)
{
PackageSearchMetadataCacheItemEntry cacheItem = await backgroundDataCache.GetPackageSearchMetadataCacheVersionedItemAsync(identity, cancellationToken);
PackageSearchMetadataContextInfo packageSearchData = await cacheItem.DetailedPackageSearchMetadataContextInfo;
PackageDeprecationMetadataContextInfo? deprecatedData = await cacheItem.PackageDeprecationMetadataContextInfo;
return (packageSearchData, deprecatedData);
}
IPackageMetadataProvider packageMetadataProvider = await GetPackageMetadataProviderAsync(packageSources, cancellationToken);
IPackageSearchMetadata packageMetadata = await packageMetadataProvider.GetPackageMetadataAsync(
identity,
includePrerelease,
cancellationToken);
PackageSearchMetadataContextInfo packageSearchMetadataContextInfo = PackageSearchMetadataContextInfo.Create(packageMetadata);
PackageDeprecationMetadataContextInfo? deprecationMetadataContextInfo = null;
PackageDeprecationMetadata? deprecationMetadata = await packageMetadata.GetDeprecationMetadataAsync();
if (deprecationMetadata != null)
{
deprecationMetadataContextInfo = PackageDeprecationMetadataContextInfo.Create(deprecationMetadata);
}
return (packageSearchMetadataContextInfo, deprecationMetadataContextInfo);
}
public V3PackageDetailControlModelTests(GlobalServiceProvider sp, V3PackageSearchMetadataFixture testData)
: base(sp, testData)
{
var solMgr = new Mock <INuGetSolutionManagerService>();
var packageSearchMetadata = new List <PackageSearchMetadataContextInfo>()
{
PackageSearchMetadataContextInfo.Create(_testData.TestData)
};
var mockSearchService = new Mock <INuGetSearchService>();
mockSearchService.Setup(x =>
x.GetPackageMetadataListAsync(
It.IsAny <string>(),
It.IsAny <IReadOnlyCollection <PackageSourceContextInfo> >(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()))
.Returns(new ValueTask <IReadOnlyCollection <PackageSearchMetadataContextInfo> >(packageSearchMetadata));
mockSearchService.Setup(x =>
x.GetDeprecationMetadataAsync(
It.IsAny <PackageIdentity>(),
It.IsAny <IReadOnlyCollection <PackageSourceContextInfo> >(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()))
.Returns(null);
mockSearchService.Setup(x => x.GetPackageMetadataAsync(
It.IsAny <PackageIdentity>(),
It.IsAny <IReadOnlyCollection <PackageSourceContextInfo> >(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()))
.Returns(new ValueTask <(PackageSearchMetadataContextInfo, PackageDeprecationMetadataContextInfo)>((packageSearchMetadata[0], null)));
var mockServiceBroker = new Mock <IServiceBroker>();
#pragma warning disable ISB001 // Dispose of proxies
mockServiceBroker.Setup(
x => x.GetProxyAsync <INuGetSearchService>(
NuGetServices.SearchService,
It.IsAny <ServiceActivationOptions>(),
It.IsAny <CancellationToken>()))
.Returns(new ValueTask <INuGetSearchService>(mockSearchService.Object));
#pragma warning restore ISB001 // Dispose of proxies
ServiceLocator.InitializePackageServiceProvider(this);
_testInstance = new PackageDetailControlModel(
mockServiceBroker.Object,
solutionManager: solMgr.Object,
Array.Empty <IProjectContextInfo>());
_testInstance.SetCurrentPackageAsync(
_testViewModel,
ItemFilter.All,
() => null).Wait();
}
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);
}
public DetailedPackageMetadata(PackageSearchMetadataContextInfo serverData, PackageDeprecationMetadataContextInfo deprecationMetadata, long?downloadCount)
{
Id = serverData.Identity.Id;
Version = serverData.Identity.Version;
Summary = serverData.Summary;
Description = serverData.Description;
Authors = serverData.Authors;
Owners = serverData.Owners;
IconUrl = serverData.IconUrl;
LicenseUrl = serverData.LicenseUrl;
ProjectUrl = serverData.ProjectUrl;
ReadmeUrl = serverData.ReadmeUrl;
ReportAbuseUrl = serverData.ReportAbuseUrl;
// Some server implementations send down an array with an empty string, which ends up as an empty string.
// In PM UI, we want Tags to work like most other properties from the server (Authors/Owners), and be null, if there is no value.
Tags = string.IsNullOrEmpty(serverData.Tags) ? null : serverData.Tags;
DownloadCount = downloadCount;
Published = serverData.Published;
IEnumerable <PackageDependencyGroup> dependencySets = serverData.DependencySets;
if (dependencySets != null && dependencySets.Any())
{
DependencySets = dependencySets.Select(e => new PackageDependencySetMetadata(e)).ToArray();
}
else
{
DependencySets = NoDependenciesPlaceholder;
}
PrefixReserved = serverData.PrefixReserved;
LicenseMetadata = serverData.LicenseMetadata;
DeprecationMetadata = deprecationMetadata;
Vulnerabilities = serverData.Vulnerabilities;
PackagePath = serverData.PackagePath;
// Determine the package details URL and text.
PackageDetailsUrl = null;
PackageDetailsText = null;
if (serverData.PackageDetailsUrl != null &&
serverData.PackageDetailsUrl.IsAbsoluteUri &&
serverData.PackageDetailsUrl.Host != null)
{
PackageDetailsUrl = serverData.PackageDetailsUrl;
PackageDetailsText = serverData.PackageDetailsUrl.Host;
// Special case the subdomain "www." - we hide it. Other subdomains are not hidden.
const string wwwDot = "www.";
if (PackageDetailsText.StartsWith(wwwDot, StringComparison.OrdinalIgnoreCase) &&
PackageDetailsText.Length > wwwDot.Length)
{
PackageDetailsText = PackageDetailsText.Substring(wwwDot.Length);
}
}
}
public void RemovesWwwSubdomainFromPackageDetailsText(string url, string expected)
{
var packageSearchMetadata = new PackageSearchMetadataBuilder.ClonedPackageSearchMetadata()
{
Identity = new PackageIdentity("NuGet.Versioning", NuGetVersion.Parse("4.3.0")),
PackageDetailsUrl = new Uri(url)
};
var packageSearchMetadataContextInfo = PackageSearchMetadataContextInfo.Create(packageSearchMetadata);
var target = new DetailedPackageMetadata(packageSearchMetadataContextInfo, deprecationMetadata: null, downloadCount: null);
Assert.Equal(expected, target.PackageDetailsText);
}
public async ValueTask<IReadOnlyCollection<PackageSearchMetadataContextInfo>> GetPackageMetadataListAsync(
string id,
IReadOnlyCollection<PackageSourceContextInfo> packageSources,
bool includePrerelease,
bool includeUnlisted,
CancellationToken cancellationToken)
{
Assumes.NotNullOrEmpty(id);
Assumes.NotNullOrEmpty(packageSources);
IPackageMetadataProvider packageMetadataProvider = await GetPackageMetadataProviderAsync(packageSources, cancellationToken);
IEnumerable<IPackageSearchMetadata> packageMetadata = await packageMetadataProvider.GetPackageMetadataListAsync(
id,
includePrerelease,
includeUnlisted,
cancellationToken);
return packageMetadata.Select(package => PackageSearchMetadataContextInfo.Create(package)).ToList();
}
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 async ValueTask <PackageSearchMetadataContextInfo> GetDetailedPackageSearchMetadataContextInfoAsync()
{
IPackageSearchMetadata detailedMetadata = await _packageMetadataProvider.GetPackageMetadataAsync(_packageSearchMetadata.Identity, includePrerelease : true, CancellationToken.None);
return(PackageSearchMetadataContextInfo.Create(detailedMetadata));
}
public async ValueTask <SearchResultContextInfo> SearchAsync(string searchText, SearchFilter filter, bool useRecommender, CancellationToken cancellationToken)
{
SearchResult <IPackageSearchMetadata>?mainFeedResult = await _mainFeed.SearchAsync(searchText, filter, cancellationToken);
SearchResult <IPackageSearchMetadata>?recommenderFeedResults = null;
if (useRecommender && _recommenderFeed != null)
{
recommenderFeedResults = await _recommenderFeed.SearchAsync(searchText, filter, cancellationToken);
}
cancellationToken.ThrowIfCancellationRequested();
_lastMainFeedSearchResult = mainFeedResult; // Store this so we can ContinueSearch, we don't store recommended as we only do that on the first search
_lastSearchFilter = filter;
if (recommenderFeedResults != null)
{
// remove duplicated recommended packages from the browse results
List <string> recommendedIds = recommenderFeedResults.Items.Select(item => item.Identity.Id).ToList();
var recommendedPackageSearchMetadataContextInfo = new List <PackageSearchMetadataContextInfo>();
foreach (IPackageSearchMetadata recommendedFeedResultItem in recommenderFeedResults.Items)
{
CacheBackgroundData(recommendedFeedResultItem, filter.IncludePrerelease);
recommendedPackageSearchMetadataContextInfo.Add(
PackageSearchMetadataContextInfo.Create(
recommendedFeedResultItem,
isRecommended: true,
recommenderVersion: (_recommenderFeed as RecommenderPackageFeed)?.VersionInfo));
}
foreach (IPackageSearchMetadata mainFeedResultItem in mainFeedResult.Items)
{
if (!recommendedIds.Contains(mainFeedResultItem.Identity.Id))
{
CacheBackgroundData(mainFeedResultItem, filter.IncludePrerelease);
recommendedPackageSearchMetadataContextInfo.Add(PackageSearchMetadataContextInfo.Create(mainFeedResultItem));
}
}
return(new SearchResultContextInfo(
recommendedPackageSearchMetadataContextInfo.ToList(),
mainFeedResult.SourceSearchStatus.ToImmutableDictionary(),
mainFeedResult.NextToken != null,
mainFeedResult.OperationId));
}
var packageSearchMetadataContextInfoCollection = new List <PackageSearchMetadataContextInfo>(mainFeedResult.Items.Count);
foreach (IPackageSearchMetadata packageSearchMetadata in mainFeedResult.Items)
{
CacheBackgroundData(packageSearchMetadata, filter.IncludePrerelease);
packageSearchMetadataContextInfoCollection.Add(PackageSearchMetadataContextInfo.Create(packageSearchMetadata));
}
return(new SearchResultContextInfo(
packageSearchMetadataContextInfoCollection,
mainFeedResult.SourceSearchStatus.ToImmutableDictionary(),
mainFeedResult.NextToken != null,
mainFeedResult.OperationId));
}
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);
}
private async ValueTask <PackageSearchMetadataContextInfo> GetDetailedPackageSearchMetadataContextInfoAsync()
{
IPackageSearchMetadata detailedMetadata = await _detailedPackageSearchMetadata.Value;
return(PackageSearchMetadataContextInfo.Create(detailedMetadata));
}
public V3PackageSolutionDetailControlModelTests(GlobalServiceProvider sp, V3PackageSearchMetadataFixture testData)
: base(sp, testData)
{
var packageSearchMetadata = new List <PackageSearchMetadataContextInfo>()
{
PackageSearchMetadataContextInfo.Create(_testData.TestData)
};
var mockSearchService = new Mock <INuGetSearchService>();
mockSearchService.Setup(x =>
x.GetPackageMetadataListAsync(
It.IsAny <string>(),
It.IsAny <IReadOnlyCollection <PackageSourceContextInfo> >(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()))
.Returns(new ValueTask <IReadOnlyCollection <PackageSearchMetadataContextInfo> >(packageSearchMetadata));
mockSearchService.Setup(x =>
x.GetDeprecationMetadataAsync(
It.IsAny <PackageIdentity>(),
It.IsAny <IReadOnlyCollection <PackageSourceContextInfo> >(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()))
.Returns(null);
mockSearchService.Setup(x => x.GetPackageMetadataAsync(
It.IsAny <PackageIdentity>(),
It.IsAny <IReadOnlyCollection <PackageSourceContextInfo> >(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()))
.Returns(new ValueTask <(PackageSearchMetadataContextInfo, PackageDeprecationMetadataContextInfo)>((packageSearchMetadata[0], null)));
var solMgr = new Mock <INuGetSolutionManagerService>();
var serviceBroker = new Mock <IServiceBroker>();
var projectManagerService = new Mock <INuGetProjectManagerService>();
projectManagerService.Setup(x => x.GetProjectsAsync(It.IsAny <CancellationToken>())).ReturnsAsync(new List <IProjectContextInfo>());
#pragma warning disable ISB001 // Dispose of proxies
serviceBroker.Setup(x => x.GetProxyAsync <INuGetProjectManagerService>(It.Is <ServiceJsonRpcDescriptor>(d => d.Moniker == NuGetServices.ProjectManagerService.Moniker), It.IsAny <ServiceActivationOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(projectManagerService.Object);
serviceBroker.Setup(
x => x.GetProxyAsync <INuGetSearchService>(
NuGetServices.SearchService,
It.IsAny <ServiceActivationOptions>(),
It.IsAny <CancellationToken>()))
.Returns(new ValueTask <INuGetSearchService>(mockSearchService.Object));
#pragma warning restore ISB001 // Dispose of proxies
NuGetUIThreadHelper.JoinableTaskFactory.Run(async() =>
{
_testInstance = await PackageSolutionDetailControlModel.CreateAsync(
solutionManager: solMgr.Object,
projects: new List <IProjectContextInfo>(),
serviceBroker: serviceBroker.Object,
CancellationToken.None);
await _testInstance.SetCurrentPackageAsync(
_testViewModel,
ItemFilter.All,
() => null);
});
}
