Ejemplo n.º 1
0
        public async Task CanGetManuallyUpdatedPackages()
        {
            var errorsAndInfos          = new ErrorsAndInfos();
            var secret                  = new SecretManuallyUpdatedPackages();
            var container               = new ContainerBuilder().UsePegh(new DummyCsArgumentPrompter()).Build();
            var manuallyUpdatedPackages = await container.Resolve <ISecretRepository>().GetAsync(secret, errorsAndInfos);

            Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsPlusRelevantInfos());
            Assert.IsNotNull(manuallyUpdatedPackages);
        }
Ejemplo n.º 2
0
        private async Task <bool> UpdateNugetPackagesForProjectAsync(string projectFileFullName, bool yesNo, IErrorsAndInfos errorsAndInfos)
        {
            using (SimpleLogger.BeginScope(SimpleLoggingScopeId.Create(nameof(UpdateNugetPackagesForProjectAsync), Guid.NewGuid().ToString()))) {
                SimpleLogger.LogInformation("Retrieving dependency ids and versions");
                var dependencyErrorsAndInfos = new ErrorsAndInfos();
                var dependencyIdsAndVersions =
                    await PackageConfigsScanner.DependencyIdsAndVersionsAsync(projectFileFullName.Substring(0, projectFileFullName.LastIndexOf('\\')), true, true, dependencyErrorsAndInfos);

                SimpleLogger.LogInformation("Retrieving manually updated packages");
                var secret = new SecretManuallyUpdatedPackages();
                var manuallyUpdatedPackages = await SecretRepository.GetAsync(secret, errorsAndInfos);

                if (errorsAndInfos.AnyErrors())
                {
                    SimpleLogger.LogInformation("Returning false");
                    return(false);
                }

                foreach (var id in dependencyIdsAndVersions.Select(dependencyIdsAndVersion => dependencyIdsAndVersion.Key).Where(id => manuallyUpdatedPackages.All(p => p.Id != id)))
                {
                    SimpleLogger.LogInformation($"Updating dependency {id}");
                    var projectFileFolder = new Folder(projectFileFullName.Substring(0, projectFileFullName.LastIndexOf('\\')));
                    ProcessRunner.RunProcess("dotnet", "remove " + projectFileFullName + " package " + id, projectFileFolder, errorsAndInfos);
                    ProcessRunner.RunProcess("dotnet", "add " + projectFileFullName + " package " + id, projectFileFolder, errorsAndInfos);
                }

                SimpleLogger.LogInformation("Retrieving dependency ids and versions once more");
                var dependencyIdsAndVersionsAfterUpdate =
                    await PackageConfigsScanner.DependencyIdsAndVersionsAsync(projectFileFullName.Substring(0, projectFileFullName.LastIndexOf('\\')), true, true, dependencyErrorsAndInfos);

                SimpleLogger.LogInformation("Determining differences");
                foreach (var dependencyIdsAndVersion in dependencyIdsAndVersionsAfterUpdate)
                {
                    var id      = dependencyIdsAndVersion.Key;
                    var version = dependencyIdsAndVersion.Value;
                    yesNo = yesNo || !dependencyIdsAndVersions.ContainsKey(id) || version != dependencyIdsAndVersions[id];
                }

                SimpleLogger.LogInformation($"Returning {yesNo}");
                return(yesNo);
            }
        }
Ejemplo n.º 3
0
        private async Task <bool> AreThereNugetUpdateOpportunitiesForProjectAsync(string projectFileFullName, IList <string> nugetFeedIds, IErrorsAndInfos errorsAndInfos)
        {
            var dependencyErrorsAndInfos = new ErrorsAndInfos();
            var dependencyIdsAndVersions = await PackageConfigsScanner.DependencyIdsAndVersionsAsync(projectFileFullName.Substring(0, projectFileFullName.LastIndexOf('\\')), true, true, dependencyErrorsAndInfos);

            var secret = new SecretManuallyUpdatedPackages();
            var manuallyUpdatedPackages = await SecretRepository.GetAsync(secret, errorsAndInfos);

            if (errorsAndInfos.AnyErrors())
            {
                return(false);
            }

            var yesNo = false;

            foreach (var dependencyIdsAndVersion in dependencyIdsAndVersions)
            {
                var id = dependencyIdsAndVersion.Key;
                if (manuallyUpdatedPackages.Any(p => p.Id == id))
                {
                    continue;
                }

                IList <IPackageSearchMetadata> remotePackages = null;
                foreach (var nugetFeedId in nugetFeedIds)
                {
                    var listingErrorsAndInfos = new ErrorsAndInfos();
                    remotePackages = await NugetFeedLister.ListReleasedPackagesAsync(nugetFeedId, id, listingErrorsAndInfos);

                    if (listingErrorsAndInfos.AnyErrors())
                    {
                        continue;
                    }
                    if (remotePackages.Any())
                    {
                        break;
                    }
                }

                if (remotePackages?.Any() != true)
                {
                    continue;
                }

                if (!Version.TryParse(dependencyIdsAndVersion.Value, out var version))
                {
                    continue;
                }

                var latestRemotePackageVersion = remotePackages.Max(p => p.Identity.Version.Version);
                if (latestRemotePackageVersion <= version || latestRemotePackageVersion?.ToString().StartsWith(version.ToString()) == true)
                {
                    continue;
                }

                errorsAndInfos.Infos.Add(string.Format(Properties.Resources.CanUpdatePackageFromTo, id, version, latestRemotePackageVersion));
                yesNo = true;
            }

            return(yesNo);
        }