public async Task GetUpdates_IncludesSemVerV2PackageVersionsWhenSemVerLevel2OrHigher(string semVerLevel)
        {
            // Arrange
            const string currentVersionString = "1.0.0";
            var          currentVersion       = NuGetVersion.Parse(currentVersionString);
            var          expected             = AvailablePackages.Where(p => NuGetVersion.Parse(p.Version) > currentVersion);

            // Act
            var resultSet = await GetCollection <V2FeedPackage>(
                (controller, options) => controller.GetUpdates(options, TestPackageId, currentVersionString, includePrerelease: true, includeAllVersions: true, semVerLevel: semVerLevel),
                $"/api/v2/GetUpdates()?packageIds='{TestPackageId}'&versions='{currentVersionString}'&includePrerelease=true&includeAllVersions=true&semVerLevel={semVerLevel}");

            // Assert
            foreach (var package in SemVer2Packages.Where(p => NuGetVersion.Parse(p.Version) > currentVersion))
            {
                // Assert all of the SemVer2 packages are included in the result.
                // Whilst at it, also check the NormalizedVersion on the OData feed.
                Assert.Single(resultSet.Where(feedPackage =>
                                              string.Equals(feedPackage.Version, package.Version) &&
                                              string.Equals(feedPackage.NormalizedVersion, package.NormalizedVersion) &&
                                              string.Equals(feedPackage.Id, package.PackageRegistration.Id)));
            }

            foreach (var package in NonSemVer2Packages.Where(p => NuGetVersion.Parse(p.Version) > currentVersion))
            {
                // Assert all of the non-SemVer2 packages are included in the result.
                // Whilst at it, also check the NormalizedVersion on the OData feed.
                Assert.Single(resultSet.Where(feedPackage =>
                                              string.Equals(feedPackage.Version, package.Version) &&
                                              string.Equals(feedPackage.NormalizedVersion, package.NormalizedVersion) &&
                                              string.Equals(feedPackage.Id, package.PackageRegistration.Id)));
            }

            Assert.Equal(expected.Count(), resultSet.Count);
        }
示例#2
0
        protected void BindPackageListGrid()
        {
            switch (this.CurrentViewMode)
            {
            case ViewMode.Installed:
                liInstalled.AddCssClass("active");
                liAvailable.RemoveCssClass("active");
                gPackageList.DataSource = InstalledPackages.Where(p => !p.Id.StartsWith(rockUpdatePackageIdPrefix) || p.Id != rockPackageId).ToList();
                break;

            case ViewMode.Available:
                liInstalled.RemoveCssClass("active");
                liAvailable.AddCssClass("active");
                gPackageList.DataSource = AvailablePackages.Where(p => !p.Id.StartsWith(rockUpdatePackageIdPrefix) || p.Id != rockPackageId).ToList();
                break;

            case ViewMode.Search:
                liInstalled.RemoveCssClass("active");
                liAvailable.RemoveCssClass("active");
                gPackageList.DataSource = NuGetService.GetLatestRemotePackages(txtSearch.Text, includeAllVersions: false).Where(p => !p.Id.StartsWith(rockUpdatePackageIdPrefix) || p.Id != rockPackageId).ToList();
                break;

            default:
                break;
            }

            gPackageList.DataBind();
        }
示例#3
0
 private void AddPackages(Repository repo)
 {
     foreach (var package in repo.Packages)
     {
         AvailablePackages.Add(package);
     }
 }
        public async Task SearchCount_IncludesSemVerV2PackageVersionsWhenSemVerLevel2OrHigher_ExcludePrerelease(string semVerLevel)
        {
            // Act
            var searchCount = await GetInt <V2FeedPackage>(
                async (controller, options) => await controller.SearchCount(options, _curatedFeedName, searchTerm: TestPackageId, semVerLevel: semVerLevel),
                $"/api/v2/curated-feed/{_curatedFeedName}/Search/$count?searchTerm='{TestPackageId}'&semVerLevel={semVerLevel}");

            // Assert
            Assert.Equal(AvailablePackages.Where(p => !p.IsPrerelease).Count(), searchCount);
        }
        public async Task Search_IncludesSemVerV2PackageVersionsWhenSemVerLevel2OrHigher_ExcludePrerelease(string semVerLevel)
        {
            // Act
            var resultSet = await GetCollection <V2FeedPackage>(
                async (controller, options) => await controller.Search(options, _curatedFeedName, searchTerm: TestPackageId, semVerLevel: semVerLevel),
                $"/api/v2/curated-feed/{_curatedFeedName}/Search?searchTerm='{TestPackageId}'&semVerLevel={semVerLevel}");

            // Assert
            AssertSemVer2PackagesIncludedInResult(resultSet, includePrerelease: false);
            Assert.Equal(AvailablePackages.Where(p => !p.IsPrerelease).Count(), resultSet.Count);
        }
        private void AssertUnavailablePackagesFilteredFromResult(IEnumerable <V2FeedPackage> resultSet)
        {
            foreach (var feedPackage in resultSet)
            {
                Assert.Empty(UnavailablePackages.Where(p => string.Equals(p.Version, feedPackage.Version)));

                // Assert each of the items in the result set is a non-SemVer v2.0.0 package
                Assert.Single(AvailablePackages.Where(p =>
                                                      string.Equals(p.Version, feedPackage.Version) &&
                                                      string.Equals(p.PackageRegistration.Id, feedPackage.Id)));
            }
        }
        public async Task GetUpdatesCount_IncludesSemVerV2PackageVersionsWhenSemVerLevel2OrHigher(string semVerLevel)
        {
            // Arrange
            const string currentVersionString = "1.0.0";
            var          currentVersion       = NuGetVersion.Parse(currentVersionString);
            var          expected             = AvailablePackages.Where(p => NuGetVersion.Parse(p.Version) > currentVersion);

            // Act
            var searchCount = await GetInt <V2FeedPackage>(
                (controller, options) => controller.GetUpdatesCount(
                    options,
                    packageIds: TestPackageId,
                    versions: currentVersionString,
                    includePrerelease: true,
                    includeAllVersions: true,
                    semVerLevel: semVerLevel),
                $"/api/v2/GetUpdates()?packageIds='{TestPackageId}'&versions='{currentVersionString}'&includePrerelease=true&includeAllVersions=true&semVerLevel={semVerLevel}");

            // Assert
            Assert.Equal(expected.Count(), searchCount);
        }
 private void HandleRequestPackageListCompleted(Action action)
 {
     IsFetchingPackages.SetValue(false);
     AvailablePackages.SetValue((AvailablePackageList)action.Payload);
 }