/// <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()); }