public async Task ShouldUpdateDotnetClassicProject()
        {
            const string oldPackageVersion     = "5.2.3";
            const string newPackageVersion     = "5.2.4";
            const string expectedPackageString =
                "<package id=\"Microsoft.AspNet.WebApi.Client\" version=\"{packageVersion}\" targetFramework=\"net47\" />";
            const string testFolder = nameof(ShouldUpdateDotnetClassicProject);

            var testProject = $"{testFolder}.csproj";

            var workDirectory = Path.Combine(_uniqueTemporaryFolder.FullPath, testFolder);

            Directory.CreateDirectory(workDirectory);
            var packagesFolder = Path.Combine(workDirectory, "packages");

            Directory.CreateDirectory(packagesFolder);

            var projectContents = _testDotNetClassicProject.Replace("{packageVersion}", oldPackageVersion,
                                                                    StringComparison.OrdinalIgnoreCase);
            var projectPath = Path.Combine(workDirectory, testProject);
            await File.WriteAllTextAsync(projectPath, projectContents);

            var packagesConfigContents = _testPackagesConfig.Replace("{packageVersion}", oldPackageVersion,
                                                                     StringComparison.OrdinalIgnoreCase);
            var packagesConfigPath = Path.Combine(workDirectory, "packages.config");
            await File.WriteAllTextAsync(packagesConfigPath, packagesConfigContents);

            await File.WriteAllTextAsync(Path.Combine(workDirectory, "nuget.config"), _nugetConfig);

            var logger          = NukeeperLogger;
            var externalProcess = new ExternalProcess(logger);

            var monoExecutor = new MonoExecutor(logger, externalProcess);

            var nuGetPath     = new NuGetPath(logger);
            var nuGetVersion  = new NuGetVersion(newPackageVersion);
            var packageSource = new PackageSource(NuGetConstants.V3FeedUrl);

            var restoreCommand = new NuGetFileRestoreCommand(logger, nuGetPath, monoExecutor, externalProcess);
            var updateCommand  = new NuGetUpdatePackageCommand(logger, nuGetPath, monoExecutor, externalProcess);

            var packageToUpdate = new PackageInProject("Microsoft.AspNet.WebApi.Client", oldPackageVersion,
                                                       new PackagePath(workDirectory, testProject, PackageReferenceType.PackagesConfig));

            await restoreCommand.Invoke(packageToUpdate, nuGetVersion, packageSource, NuGetSources.GlobalFeed);

            await updateCommand.Invoke(packageToUpdate, nuGetVersion, packageSource, NuGetSources.GlobalFeed);

            var contents = await File.ReadAllTextAsync(packagesConfigPath);

            Assert.That(contents,
                        Does.Contain(expectedPackageString.Replace("{packageVersion}", newPackageVersion,
                                                                   StringComparison.OrdinalIgnoreCase)));
            Assert.That(contents,
                        Does.Not.Contain(expectedPackageString.Replace("{packageVersion}", oldPackageVersion,
                                                                       StringComparison.OrdinalIgnoreCase)));
        }
        public async Task WhenNugetRestoreIsCalledThenArgsIncludePackageDirectory()
        {
            var logger          = Substitute.For <INuKeeperLogger>();
            var nuGetPath       = Substitute.For <INuGetPath>();
            var monoExecuter    = Substitute.For <IMonoExecutor>();
            var externalProcess = Substitute.For <IExternalProcess>();
            var file            = new FileInfo("packages.config");

            nuGetPath.Executable.Returns(@"c:\DoesNotExist\nuget.exe");
            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                externalProcess.Run(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <string>(), Arg.Any <bool>()).Returns(new ProcessOutput("", "", 0));
            }
            else
            {
                monoExecuter.CanRun().Returns(true);
                monoExecuter.Run(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <string>(), Arg.Any <bool>()).Returns(new ProcessOutput("", "", 0));
            }
            var cmd = new NuGetFileRestoreCommand(logger, nuGetPath, monoExecuter, externalProcess);

            await cmd.Invoke(file, NuGetSources.GlobalFeed);

            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                await externalProcess.Received(1).Run(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <string>(), Arg.Any <bool>());

                await externalProcess.ReceivedWithAnyArgs().Run(Arg.Any <string>(), Arg.Any <string>(), $"restore {file.Name} - Source ${NuGetSources.GlobalFeed} -NonInteractive -PackagesDirectory ..\\packages", Arg.Any <bool>());
            }
            else
            {
                logger.DidNotReceiveWithAnyArgs().Error(Arg.Any <string>(), Arg.Any <System.Exception>());
                await monoExecuter.Received(1).Run(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <string>(), Arg.Any <bool>());

                await monoExecuter.ReceivedWithAnyArgs().Run(Arg.Any <string>(), Arg.Any <string>(), $"restore {file.Name} - Source ${NuGetSources.GlobalFeed} -NonInteractive -PackagesDirectory ..\\packages", Arg.Any <bool>());
            }
        }