/// <summary>
/// Get all versions for a specific package Id.
/// </summary>
/// <param name="sourceRepository"></param>
/// <param name="packageId"></param>
/// <param name="project"></param>
/// <param name="includePrerelease"></param>
/// <returns></returns>
public static IEnumerable<NuGetVersion> GetAllVersionsForPackageId(SourceRepository sourceRepository, string packageId, NuGetProject project, bool includePrerelease)
{
IEnumerable<string> targetFrameworks = GetProjectTargetFrameworks(project);
SearchFilter searchfilter = new SearchFilter();
searchfilter.IncludePrerelease = includePrerelease;
searchfilter.SupportedFrameworks = targetFrameworks;
searchfilter.IncludeDelisted = false;
PSSearchResource resource = sourceRepository.GetResource<PSSearchResource>();
PSSearchMetadata result = null;
IEnumerable<NuGetVersion> allVersions = Enumerable.Empty<NuGetVersion>();
try
{
Task<IEnumerable<PSSearchMetadata>> task = resource.Search(packageId, searchfilter, 0, 30, CancellationToken.None);
result = task.Result
.Where(p => string.Equals(p.Identity.Id, packageId, StringComparison.OrdinalIgnoreCase))
.FirstOrDefault();
allVersions = result.Versions;
}
catch (Exception)
{
if (result == null || !allVersions.Any())
{
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
Resources.UnknownPackage, packageId));
}
}
return result.Versions;
}
private UISearchMetadata CreatePackageSearchResult(IPackage package,
SearchFilter filters,
CancellationToken cancellationToken)
{
var id = package.Id;
var version = V2Utilities.SafeToNuGetVer(package.Version);
var title = package.Title;
var summary = package.Summary;
if (string.IsNullOrWhiteSpace(summary))
{
summary = package.Description;
}
if (string.IsNullOrEmpty(title))
{
title = id;
}
var iconUrl = package.IconUrl;
var identity = new PackageIdentity(id, version);
var versions = new Lazy<Task<IEnumerable<VersionInfo>>>(() =>
GetVersionInfoAsync(package, filters, cancellationToken));
var searchMetaData = new UISearchMetadata(identity,
title,
summary,
iconUrl,
versions,
UIMetadataResourceV2.GetVisualStudioUIPackageMetadata(package));
return searchMetaData;
}
public override async Task<IEnumerable<ServerPackageMetadata>> Search(string searchTerm, SearchFilter filters, int skip, int take, CancellationToken cancellationToken)
{
List<ServerPackageMetadata> results = new List<ServerPackageMetadata>();
var searchResultJsonObjects = await _searchResource.Search(searchTerm, filters, skip, take, cancellationToken);
foreach (JObject package in searchResultJsonObjects)
{
// TODO: verify this parsing is needed
string id = package.Value<string>(Properties.PackageId);
NuGetVersion version = NuGetVersion.Parse(package.Value<string>(Properties.Version));
PackageIdentity topPackage = new PackageIdentity(id, version);
Uri iconUrl = GetUri(package, Properties.IconUrl);
string summary = package.Value<string>(Properties.Summary);
if (string.IsNullOrWhiteSpace(summary))
{
// summary is empty. Use its description instead.
summary = package.Value<string>(Properties.Description);
}
// retrieve metadata for the top package
results.Add(PackageMetadataParser.ParseMetadata(package));
}
return results;
}
/// <summary>
/// Basic search
/// </summary>
public override async Task<IEnumerable<SimpleSearchMetadata>> Search(string searchTerm, SearchFilter filters, int skip, int take, CancellationToken cancellationToken)
{
var results = new List<SimpleSearchMetadata>();
foreach (var result in await _rawSearch.Search(searchTerm, filters, skip, take, cancellationToken))
{
var version = NuGetVersion.Parse(result["version"].ToString());
var identity = new PackageIdentity(result["id"].ToString(), version);
var description = result["description"].ToString();
var allVersions = new List<NuGetVersion>();
foreach (var versionObj in ((JArray)result["versions"]))
{
allVersions.Add(NuGetVersion.Parse(versionObj["version"].ToString()));
}
var data = new SimpleSearchMetadata(identity, description, allVersions);
results.Add(data);
}
return results;
}
public override async Task<IEnumerable<PSSearchMetadata>> Search(string searchTerm,
SearchFilter filters,
int skip,
int take,
CancellationToken cancellationToken)
{
return await GetSearchResultsAsync(searchTerm, filters, skip, take, cancellationToken);
}
/// <summary>
/// Retrieve search results
/// </summary>
public virtual async Task<IEnumerable<ApiAppPackage>> Search(
string searchTerm,
SearchFilter filters,
int skip,
int take,
CancellationToken cancellationToken)
{
IEnumerable<JObject> jsonResults = await _rawSearch.Search(searchTerm, filters, skip, take, cancellationToken);
return jsonResults.Select(e => Parse(e)).ToArray();
}
public async Task UISearch_Empty()
{
var resource = await SourceRepository.GetResourceAsync<UISearchResource>();
var filter = new SearchFilter();
filter.IncludePrerelease = false;
var results = await resource.Search("asdlkfjasdflasdflsfdjlasdfaksldfasdflasdf", filter, 0, 10, CancellationToken.None);
Assert.Equal(0, results.Count());
}
public async Task<SearchResult<IPackageSearchMetadata>> SearchAsync(string searchText, SearchFilter filter, CancellationToken cancellationToken)
{
var searchTasks = TaskCombinators.ObserveErrorsAsync(
_sourceRepositories,
r => r.PackageSource.Name,
(r, t) => r.SearchAsync(searchText, filter, PageSize, t),
LogError,
cancellationToken);
return await WaitForCompletionOrBailOutAsync(searchText, searchTasks, cancellationToken);
}
public static Task<SearchResult<IPackageSearchMetadata>> SearchAsync(this SourceRepository sourceRepository, string searchText, SearchFilter searchFilter, int pageSize, CancellationToken cancellationToken)
{
var searchToken = new FeedSearchContinuationToken
{
SearchString = searchText,
SearchFilter = searchFilter,
StartIndex = 0
};
return sourceRepository.SearchAsync(searchToken, pageSize, cancellationToken);
}
public override async Task<IEnumerable<PSSearchMetadata>> Search(string search, SearchFilter filters, int skip, int take, CancellationToken token)
{
// TODO: stop using UI search
var searchResultJsonObjects = await _searchResource.Search(search, filters, skip, take, token);
List<PSSearchMetadata> powerShellSearchResults = new List<PSSearchMetadata>();
foreach (UISearchMetadata result in searchResultJsonObjects)
{
powerShellSearchResults.Add(new PSSearchMetadata(result.Identity, result.Versions.Select(v => v.Version), result.Summary));
}
return powerShellSearchResults;
}
public override async Task<IEnumerable<UISearchMetadata>> Search(string searchTerm, SearchFilter filters, int skip, int take, CancellationToken cancellationToken)
{
List<UISearchMetadata> visualStudioUISearchResults = new List<UISearchMetadata>();
var searchResultJsonObjects = await _searchResource.Search(searchTerm, filters, skip, take, cancellationToken);
foreach (JObject searchResultJson in searchResultJsonObjects)
{
visualStudioUISearchResults.Add(await GetVisualStudioUISearchResult(searchResultJson, filters.IncludePrerelease, cancellationToken));
}
return visualStudioUISearchResults;
}
public async Task<PackageSearchResponse> PackageSearch(PackageSearchRequest request)
{
var projectPath = request.ProjectPath;
if (request.ProjectPath.EndsWith(".json"))
{
projectPath = Path.GetDirectoryName(projectPath);
}
if (!string.IsNullOrWhiteSpace(projectPath))
{
if (request.SupportedFrameworks == null)
request.SupportedFrameworks = Enumerable.Empty<string>();
if (request.PackageTypes == null)
request.PackageTypes = Enumerable.Empty<string>();
if (request.Sources == null)
request.Sources = Enumerable.Empty<string>();
var token = CancellationToken.None;
var filter = new SearchFilter()
{
SupportedFrameworks = request.SupportedFrameworks,
IncludePrerelease = request.IncludePrerelease,
PackageTypes = request.PackageTypes
};
var tasks = new List<Task<IEnumerable<SimpleSearchMetadata>>>();
var repositoryProvider = new OmniSharpSourceRepositoryProvider(projectPath);
var repos = repositoryProvider.GetRepositories().ToArray();
if (request.Sources.Any())
{
// Reduce to just the sources we requested
repos = repos.Join(request.Sources, x => x.PackageSource.Source, x => x, (x, y) => x).ToArray();
}
foreach (var repo in repos)
{
var resource = await repo.GetResourceAsync<SimpleSearchResource>();
if (resource != null)
{
tasks.Add(resource.Search(request.Search, filter, 0, 50, token));
}
}
var results = await Task.WhenAll(tasks);
return MergeResults(results, repos);
}
return new PackageSearchResponse();
}
public Task<SearchResult<IPackageSearchMetadata>> SearchAsync (string searchText, SearchFilter filter, CancellationToken cancellationToken)
{
var results = new SearchResult<IPackageSearchMetadata> {
RefreshToken = new RefreshToken { },
SourceSearchStatus = new Dictionary<string, LoadingStatus> {
{ "Test", LoadingStatus.Loading }
}
};
SearchText = searchText;
SearchFilter = filter;
return Task.FromResult (results);
}
private async Task<IEnumerable<UISearchMetadata>> GetSearchResultsForVisualStudioUI(string searchTerm, SearchFilter filters, int skip, int take, CancellationToken cancellationToken)
{
return await Task.Run(async () =>
{
var query = V2Client.Search(
searchTerm,
filters.SupportedFrameworks,
filters.IncludePrerelease);
// V2 sometimes requires that we also use an OData filter for
// latest /latest prerelease version
if (filters.IncludePrerelease)
{
query = query.Where(p => p.IsAbsoluteLatestVersion);
}
else
{
query = query.Where(p => p.IsLatestVersion);
}
query = query.OrderByDescending(p => p.DownloadCount)
.ThenBy(p => p.Id);
// Some V2 sources, e.g. NuGet.Server, local repository, the result contains all
// versions of each package. So we need to group the result by Id.
var collapsedQuery = query.AsEnumerable().AsCollapsed();
// execute the query
var allPackages = collapsedQuery
.Skip(skip)
.Take(take)
.ToList();
// fetch version info in parallel
Queue<Task<UISearchMetadata>> tasks = new Queue<Task<UISearchMetadata>>();
foreach (var p in allPackages)
{
tasks.Enqueue(CreatePackageSearchResult(p, filters, cancellationToken));
}
List<UISearchMetadata> results = new List<UISearchMetadata>();
while (tasks.Count > 0)
{
UISearchMetadata metadata = await tasks.Dequeue();
results.Add(metadata);
}
return results;
});
}
public async Task TestAllSearchTitle(string SourceUrl)
{
SourceRepository repo = GetSourceRepository(SourceUrl);
UISearchResource resource = repo.GetResource<UISearchResource>();
SearchFilter filter = new SearchFilter();
string searchTerm = "Json";
IEnumerable<UISearchMetadata> uiSearchResults = await resource.Search(searchTerm, filter, 0, 100, new CancellationToken());
UISearchMetadata metadata = uiSearchResults.Where(e => StringComparer.OrdinalIgnoreCase.Equals("newtonsoft.json", e.Identity.Id)).Single();
// TODO: check the title value once the server is updated
Assert.True(!String.IsNullOrEmpty(metadata.Title));
Assert.True(!String.IsNullOrEmpty(metadata.LatestPackageMetadata.Title));
}
public async Task UISearch_Basic()
{
var resource = await SourceRepository.GetResourceAsync<UISearchResource>();
var filter = new SearchFilter();
filter.IncludePrerelease = false;
var results = (await resource.Search("elmah", filter, 0, 10, CancellationToken.None)).ToList();
Assert.Equal(10, results.Count());
Assert.Equal("elmah", results[0].Identity.Id);
Assert.True(results[0].Versions.Count() > 3);
// Null for now
//Assert.True(first.LatestPackageMetadata.Description.Length > 10);
}
public override async Task<IEnumerable<ServerPackageMetadata>> Search(string searchTerm, SearchFilter filters, int skip, int take, CancellationToken cancellationToken)
{
return await Task.Run(() =>
{
var query = _repository.Search(
searchTerm,
filters.SupportedFrameworks,
filters.IncludePrerelease);
// V2 sometimes requires that we also use an OData filter for latest/latest prerelease version
if (filters.IncludePrerelease)
{
query = query.Where(p => p.IsAbsoluteLatestVersion);
}
else
{
query = query.Where(p => p.IsLatestVersion);
}
// execute the query
var allPackages = query
.Skip(skip)
.Take(take)
.ToList();
var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
var results = new List<ServerPackageMetadata>();
foreach (var package in allPackages)
{
if (seen.Add(package.Id))
{
var highest = allPackages.Where(p => StringComparer.OrdinalIgnoreCase.Equals(p.Id, package.Id))
.OrderByDescending(p => p.Version).First();
var metadata = ParsePackageMetadataV2.Parse(highest);
results.Add(metadata);
}
}
return results;
});
}
public async Task UISearch_Default()
{
var resource = await SourceRepository.GetResourceAsync<UISearchResource>();
var filter = new SearchFilter();
filter.IncludePrerelease = false;
var results = (await resource.Search(string.Empty, filter, 0, 10, CancellationToken.None)).ToList();
Assert.Equal(10, results.Count);
Assert.Equal("EntityFramework", results[0].Identity.Id);
Assert.True(results[0].Versions.Count() > 3);
Assert.Equal("Newtonsoft.Json", results[1].Identity.Id);
Assert.Equal("jQuery", results[2].Identity.Id);
// Null for now
//Assert.True(first.LatestPackageMetadata.Description.Length > 10);
}
private async Task<IEnumerable<PSSearchMetadata>> GetSearchResultsAsync(string searchTerm,
SearchFilter filters,
int skip,
int take,
CancellationToken cancellationToken)
{
return await Task.Run(() =>
{
var query = V2Client.Search(
searchTerm,
filters.SupportedFrameworks,
filters.IncludePrerelease);
// V2 sometimes requires that we also use an OData filter for
// latest /latest prerelease version
if (filters.IncludePrerelease)
{
query = query.Where(p => p.IsAbsoluteLatestVersion);
}
else
{
query = query.Where(p => p.IsLatestVersion);
}
query = query
.OrderByDescending(p => p.DownloadCount)
.ThenBy(p => p.Id);
// Some V2 sources, e.g. NuGet.Server, local repository, the result contains all
// versions of each package. So we need to group the result by Id.
var collapsedQuery = query.AsEnumerable().AsCollapsed();
// execute the query
var allPackages = collapsedQuery
.Skip(skip)
.Take(take)
.ToArray();
return allPackages
.Select(p => CreatePackageSearchResult(p, filters, cancellationToken))
.ToArray();
});
}
private async Task<UISearchMetadata> CreatePackageSearchResult(IPackage package, SearchFilter filters, CancellationToken cancellationToken)
{
return await Task.Run(() =>
{
cancellationToken.ThrowIfCancellationRequested();
// apply the filters to the version list returned
var versions = V2Client.FindPackagesById(package.Id)
.Where(p => filters.IncludeDelisted || !p.Published.HasValue || p.Published.Value.Year > 1901)
.Where(v => filters.IncludePrerelease || String.IsNullOrEmpty(v.Version.SpecialVersion)).ToArray();
if (!versions.Any())
{
versions = new[] { package };
}
string id = package.Id;
NuGetVersion version = V2Utilities.SafeToNuGetVer(package.Version);
string title = package.Title;
string summary = package.Summary;
var nuGetVersions = versions.Select(p =>
new VersionInfo(V2Utilities.SafeToNuGetVer(p.Version), p.DownloadCount));
if (String.IsNullOrWhiteSpace(summary))
{
summary = package.Description;
}
if (String.IsNullOrEmpty(title))
{
title = id;
}
Uri iconUrl = package.IconUrl;
PackageIdentity identity = new PackageIdentity(id, version);
UISearchMetadata searchMetaData = new UISearchMetadata(identity, title, summary, iconUrl, nuGetVersions, UIMetadataResourceV2.GetVisualStudioUIPackageMetadata(package));
return searchMetaData;
});
}
public override Task<IEnumerable<SimpleSearchMetadata>> Search(string searchTerm, SearchFilter filters, int skip, int take, CancellationToken cancellationToken)
{
var query = V2Client.Search(
searchTerm,
filters.SupportedFrameworks,
filters.IncludePrerelease);
// V2 sometimes requires that we also use an OData filter for latest/latest prerelease version
if (filters.IncludePrerelease)
{
query = query.Where(p => p.IsAbsoluteLatestVersion);
}
else
{
query = query.Where(p => p.IsLatestVersion);
}
if (V2Client is LocalPackageRepository)
{
// if the repository is a local repo, then query contains all versions of packages.
// we need to explicitly select the latest version.
query = query.OrderBy(p => p.Id)
.ThenByDescending(p => p.Version)
.GroupBy(p => p.Id)
.Select(g => g.First());
}
// Now apply skip and take and the rest of the party
var result = (IEnumerable<SimpleSearchMetadata>)query
.Skip(skip)
.Take(take)
.ToList()
.AsParallel()
.AsOrdered()
.Select(p => CreatePackageSearchResult(p))
.ToList();
return Task.FromResult(result);
}
private PSSearchMetadata CreatePackageSearchResult(IPackage package,
SearchFilter filters,
CancellationToken cancellationToken)
{
var id = package.Id;
var version = V2Utilities.SafeToNuGetVer(package.Version);
var summary = package.Summary;
if (string.IsNullOrWhiteSpace(summary))
{
summary = package.Description;
}
var iconUrl = package.IconUrl;
var identity = new PackageIdentity(id, version);
var versions = new Lazy<Task<IEnumerable<NuGetVersion>>>(() =>
GetVersionInfoAsync(package, filters, cancellationToken));
var searchMetaData = new PSSearchMetadata(identity, versions, summary);
return searchMetaData;
}
public async Task DependencyTest(string keyword, string version, string framework, bool hasDependencies)
{
var factory = new NuGetFactory("NuGet", "https://api.nuget.org/v3/index.json");
var baseMetaResource = await factory.GetMetadata();
var metaResource = await factory.GetUIMetadata();
var depResource = await factory.GetDependency();
var searchResource = await factory.GetSearch();
var versionNG = new NuGetVersion(version);
var fx = NuGetFramework.Parse(framework);
var packageId = new PackageIdentity(keyword, versionNG);
Assert.NotNull(fx);
Assert.NotNull(versionNG);
// Search with keyword
var filter = new SearchFilter { IncludePrerelease = true };
var packagesFound = await searchResource.Search(keyword, filter, 0, 10, CancellationToken.None);
foreach (var package in packagesFound)
{
Assert.NotNull(package.Identity.Id);
Assert.NotNull(package.Identity.Version);
Debug.WriteLine(package.Identity.ToString());
Debug.WriteLine(package.Identity.Version.ToNormalizedString());
}
// Get metadata for packageId
var metaResult = await metaResource.GetMetadata(packageId.Id, true, false, CancellationToken.None);
var versions = await (await factory.GetMetadata()).GetVersions(packageId.Id, CancellationToken.None);
foreach (var uiPackageMetadata in metaResult)
{
foreach (var dset in uiPackageMetadata.DependencySets)
{
Assert.NotNull(dset.TargetFramework.DotNetFrameworkName);
foreach (var depends in dset.Packages)
{
Debug.WriteLine(depends.ToString());
Assert.NotNull(depends.ToString());
}
}
}
foreach (var versionF in versions)
{
Assert.NotNull(versionF.ToNormalizedString());
}
// Get dependency for packageId + version + fx
var packageDependencyInfo = await depResource.ResolvePackage(packageId, fx, CancellationToken.None);
foreach (var dependency in packageDependencyInfo.Dependencies)
{
var allVersions = await baseMetaResource.GetVersions(dependency.Id, CancellationToken.None);
var bestMatch = dependency.VersionRange.FindBestMatch(allVersions);
Assert.NotNull(bestMatch);
}
}
/// <summary> /// Returns search entries /// </summary> public abstract Task<IEnumerable<SimpleSearchMetadata>> Search(string searchTerm, SearchFilter filters, int skip, int take, CancellationToken cancellationToken);
public virtual async Task<JObject> SearchPage(string searchTerm, SearchFilter filters, int skip, int take, CancellationToken cancellationToken)
{
for (int i = 0; i < _searchEndpoints.Length; i++)
{
var endpoint = _searchEndpoints[i];
var queryUrl = new UriBuilder(endpoint.AbsoluteUri);
string queryString =
"q=" + searchTerm +
"&skip=" + skip.ToString() +
"&take=" + take.ToString() +
"&includePrerelease=" + filters.IncludePrerelease.ToString().ToLowerInvariant();
if (filters.IncludeDelisted)
{
queryString += "&includeDelisted=true";
}
if (filters.SupportedFrameworks != null && filters.SupportedFrameworks.Any())
{
string frameworks =
String.Join("&",
filters.SupportedFrameworks.Select(
fx => "supportedFramework=" + fx.ToString()));
queryString += "&" + frameworks;
}
if (filters.PackageTypes != null && filters.PackageTypes.Any())
{
string types = String.Join("&",
filters.PackageTypes.Select(
s => "packageTypeFilter=" + s));
queryString += "&" + types;
}
queryUrl.Query = queryString;
if (!cancellationToken.IsCancellationRequested)
{
try
{
JObject searchJson = await _client.GetJObjectAsync(queryUrl.Uri, cancellationToken);
if (searchJson != null)
{
return searchJson;
}
}
catch (Exception)
{
Debug.Fail("Search failed");
if (i == _searchEndpoints.Length - 1)
{
// throw on the last one
throw;
}
}
}
}
// TODO: get a better message for this
throw new NuGetProtocolException(Strings.Protocol_MissingSearchService);
}
private async Task<IReadOnlyList<PackageData>> GetPackages(string searchTerm, bool includePrerelease, bool allVersions, bool exactMatch, CancellationToken cancellationToken)
{
if (exactMatch)
{
var exactResult = _repository.FindPackagesById(searchTerm);
if (!allVersions)
{
exactResult = includePrerelease
? exactResult.Where(x => x.IsAbsoluteLatestVersion)
: exactResult.Where(p => p.IsLatestVersion);
}
var packages = exactResult.ToArray();
if (packages.Any())
{
return new[] { new PackageData(packages) };
}
return Array.Empty<PackageData>();
}
var filter = new SearchFilter(new[] { TargetFrameworkFullName }, includePrerelease, includeDelisted: false);
foreach (var sourceRepository in _sourceRepositoryProvider.GetRepositories())
{
IPackageSearchMetadata[] result;
try
{
result = await sourceRepository.SearchAsync(searchTerm, filter, MaxSearchResults, cancellationToken).ConfigureAwait(false);
}
catch (FatalProtocolException)
{
continue;
}
if (result.Length > 0)
{
var packages = result.Select(x => new PackageData(x)).ToArray();
await Task.WhenAll(packages.Select(x => x.Initialize())).ConfigureAwait(false);
return packages;
}
}
return Array.Empty<PackageData>();
}
public Task<IEnumerable<NuGetVersion>> GetVersionInfoAsync(IPackage package,
SearchFilter filters,
CancellationToken cancellationToken)
{
return Task.Run(() =>
{
cancellationToken.ThrowIfCancellationRequested();
// apply the filters to the version list returned
var versions = V2Client.FindPackagesById(package.Id)
.Where(p => filters.IncludeDelisted || !p.Published.HasValue || p.Published.Value.Year > 1901)
.Where(v => filters.IncludePrerelease || string.IsNullOrEmpty(v.Version.SpecialVersion)).ToArray();
if (!versions.Any())
{
versions = new[] { package };
}
var nuGetVersions = versions.Select(p => V2Utilities.SafeToNuGetVer(p.Version));
return nuGetVersions;
});
}
/// <summary>
/// Retrieves search results
/// </summary>
public abstract Task <IEnumerable <ServerPackageMetadata> > Search(
string searchTerm,
SearchFilter filters,
int skip,
int take,
CancellationToken cancellationToken);
public static async Task<IPackageSearchMetadata[]> SearchAsync(this SourceRepository sourceRepository, string searchText, SearchFilter searchFilter, int pageSize, CancellationToken cancellationToken)
{
var searchResource = await sourceRepository.GetResourceAsync<PackageSearchResource>(cancellationToken).ConfigureAwait(false);
if (searchResource != null)
{
var searchResults = await searchResource.SearchAsync(
searchText,
searchFilter,
0,
pageSize,
NullLogger.Instance,
cancellationToken).ConfigureAwait(false);
if (searchResults != null)
{
return searchResults.ToArray();
}
}
return Array.Empty<IPackageSearchMetadata>();
}
public virtual async Task<IEnumerable<JObject>> Search(string searchTerm, SearchFilter filters, int skip, int take, CancellationToken cancellationToken)
{
var results = await SearchPage(searchTerm, filters, skip, take, cancellationToken);
var data = results.Value<JArray>("data");
if (data == null)
{
return Enumerable.Empty<JObject>();
}
return data.Select(e => e as JObject).Where(e => e != null);
}
public async Task TestAllSearchResources(string SourceUrl)
{
SourceRepository repo = GetSourceRepository(SourceUrl);
UISearchResource resource = repo.GetResource<UISearchResource>();
SearchLatestResource latestResource = repo.GetResource<SearchLatestResource>();
//Check if we are able to obtain a resource
Assert.True(resource != null);
//check if the resource is of type IVsSearch.
SearchFilter filter = new SearchFilter(); //create a dummy filter.
List<FrameworkName> fxNames = new List<FrameworkName>();
fxNames.Add(new FrameworkName(".NET Framework, Version=4.0"));
filter.SupportedFrameworks = fxNames.Select(e => e.ToString());
string SearchTerm = "Elmah";
IEnumerable<UISearchMetadata> uiSearchResults = await resource.Search(SearchTerm, filter, 0, 100, new CancellationToken());
var latestSearchResults = await latestResource.Search(SearchTerm, filter, 0, 100, CancellationToken.None);
// Check if non empty search result is returned.
Assert.True(uiSearchResults.Count() > 0);
//check if there is atleast one result which has Id exactly as the search terms.
Assert.True(uiSearchResults.Any(p => p.Identity.Id.Equals(SearchTerm, StringComparison.OrdinalIgnoreCase)));
foreach (var result in uiSearchResults)
{
Assert.Equal(result.Identity.Id, result.LatestPackageMetadata.Identity.Id);
Assert.Equal(result.Identity.Version.ToNormalizedString(), result.LatestPackageMetadata.Identity.Version.ToNormalizedString());
}
// Verify search and latest search return the same results
var searchEnumerator = uiSearchResults.GetEnumerator();
var latestEnumerator = latestSearchResults.GetEnumerator();
for (int i=0; i < 10; i++)
{
searchEnumerator.MoveNext();
latestEnumerator.MoveNext();
Assert.Equal(searchEnumerator.Current.LatestPackageMetadata.Identity.Id, latestEnumerator.Current.Id);
Assert.Equal(searchEnumerator.Current.LatestPackageMetadata.LicenseUrl, latestEnumerator.Current.LicenseUrl);
//Assert.Equal(searchEnumerator.Current.LatestPackageMetadata.ReportAbuseUrl, latestEnumerator.Current.ReportAbuseUrl);
Assert.Equal(searchEnumerator.Current.LatestPackageMetadata.RequireLicenseAcceptance, latestEnumerator.Current.RequireLicenseAcceptance);
Assert.Equal(searchEnumerator.Current.LatestPackageMetadata.Summary, latestEnumerator.Current.Summary);
Assert.Equal(searchEnumerator.Current.LatestPackageMetadata.Authors, String.Join(" ", latestEnumerator.Current.Authors));
Assert.Equal(searchEnumerator.Current.LatestPackageMetadata.Title, latestEnumerator.Current.Title);
}
PSSearchResource psResource = repo.GetResource<PSSearchResource>();
IEnumerable<PSSearchMetadata> psSearchResults = await psResource.Search(SearchTerm, filter, 0, 100, new System.Threading.CancellationToken());
SimpleSearchResource simpleSearch = repo.GetResource<SimpleSearchResource>();
IEnumerable<SimpleSearchMetadata> simpleSearchResults = await simpleSearch.Search(SearchTerm, filter, 0, 100, new System.Threading.CancellationToken());
//Check that exact search results are returned irrespective of search resource ( UI, powershell and commandline).
Assert.True(uiSearchResults.Count() == psSearchResults.Count());
Assert.True(psSearchResults.Count() == simpleSearchResults.Count());
}
