//returns the lock file, if it changed
async Task <string> RestorePackagesInternal(
BuildIntegratedNuGetProject project,
CancellationToken cancellationToken)
{
var now = DateTime.UtcNow;
Action <SourceCacheContext> cacheContextModifier = c => c.MaxAge = now;
var spec = await MonoDevelopDependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, project, context, cancellationToken);
context.AddToCache(spec);
RestoreResult restoreResult = await DependencyGraphRestoreUtility.RestoreProjectAsync(
solutionManager,
project,
context,
new RestoreCommandProvidersCache(),
cacheContextModifier,
sourceRepositories,
Guid.NewGuid(),
context.Logger,
cancellationToken);
if (restoreResult.Success)
{
if (!object.Equals(restoreResult.LockFile, restoreResult.PreviousLockFile))
{
return(restoreResult.LockFilePath);
}
}
else
{
ReportRestoreError(restoreResult);
}
return(null);
}
public IReadOnlyCollection <string> GetFiles()
{
// todo: https://github.com/NuGet/Home/issues/8605
return(new List <string>()
{
DependencyGraphRestoreUtility.GetDefaultDGSpecFileName()
});
}
public async Task DependencyGraphRestoreUtility_NoopRestoreTest()
{
// Arrange
var projectName = "testproj";
var logger = new TestLogger();
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
var sources = new[]
{
Repository.Factory.GetVisualStudio(new PackageSource("https://www.nuget.org/api/v2/"))
};
var targetFramework = NuGetFramework.Parse("net46");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(targetFramework, new TestNuGetProjectContext());
var project = new TestMSBuildNuGetProject(msBuildNuGetProjectSystem, rootFolder, projectFolder.FullName);
var effectiveGlobalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(NullSettings.Instance);
var restoreContext = new DependencyGraphCacheContext(logger, NullSettings.Instance);
var projects = new List <IDependencyGraphProject>()
{
project
};
using (var solutionManager = new TestSolutionManager())
{
solutionManager.NuGetProjects.Add(project);
// Act
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sources,
Guid.Empty,
false,
true,
logger,
CancellationToken.None);
// Assert
Assert.Equal(0, logger.Errors);
Assert.Equal(0, logger.Warnings);
}
}
}
public async Task RestorePackages(
IEnumerable <BuildIntegratedNuGetProject> projects,
CancellationToken cancellationToken)
{
var spec = await MonoDevelopDependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, projects, context, cancellationToken);
var now = DateTime.UtcNow;
Action <SourceCacheContext> cacheContextModifier = c => c.MaxAge = now;
bool forceRestore = false;
bool isRestoreOriginalAction = true;
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
spec,
context,
new RestoreCommandProvidersCache(),
cacheContextModifier,
sourceRepositories,
Guid.NewGuid(),
forceRestore,
isRestoreOriginalAction,
context.Logger,
cancellationToken);
bool restoreFailed = false;
int noOpRestoreCount = 0;
foreach (RestoreSummary restoreSummary in restoreSummaries)
{
if (restoreSummary.Success && restoreSummary.NoOpRestore)
{
noOpRestoreCount++;
}
else if (!restoreSummary.Success)
{
restoreFailed = true;
}
}
if (noOpRestoreCount == projects.Count())
{
// Nothing to do.
return;
}
if (restoreFailed)
{
logger.LogInformation(string.Empty);
logger.LogSavedErrors();
throw new ApplicationException(GettextCatalog.GetString("Restore failed."));
}
await OnProjectsRestored(projects);
}
public async Task BuildIntegratedRestoreUtility_RestoreProjectNameProjectJson()
{
// Arrange
var projectName = "testproj";
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "testproj.project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName);
var sources = new List <SourceRepository>
{
Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/")
};
var projectTargetFramework = NuGetFramework.Parse("uap10.0");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework,
new TestNuGetProjectContext());
var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName);
using (var solutionManager = new TestSolutionManager())
{
solutionManager.NuGetProjects.Add(project);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger, NullSettings.Instance);
// Act
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sources,
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
// Assert
Assert.True(File.Exists(Path.Combine(projectFolder.FullName, "testproj.project.lock.json")));
Assert.True(testLogger.Errors == 0);
Assert.False(File.Exists(Path.Combine(projectFolder.FullName, "project.lock.json")));
}
}
}
public static Task <DependencyGraphSpec> GetSolutionRestoreSpec(
IMonoDevelopSolutionManager solutionManager,
IEnumerable <BuildIntegratedNuGetProject> projects,
DependencyGraphCacheContext context,
CancellationToken cancellationToken)
{
if (projects.Count() > MaxSupportedProjectsForMSBuildHost)
{
return(MSBuildUtility.GetSolutionRestoreSpec(solutionManager.Solution, projects, solutionManager.Configuration, context.Logger, cancellationToken));
}
return(DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, context));
}
public async Task RestoreAsync_WithProgressReporter_WhenFilesAreWriten_ProgressIsReported()
{
// Arrange
using var pathContext = new SimpleTestPathContext();
var settings = Settings.LoadDefaultSettings(pathContext.SolutionRoot);
var packageSpec = ProjectTestHelpers.GetPackageSpec(settings, projectName: "projectName", rootPath: pathContext.SolutionRoot);
var progressReporter = new Mock <IRestoreProgressReporter>();
// Act
IReadOnlyList <RestoreSummary> result = await DependencyGraphRestoreUtility.RestoreAsync(
ProjectTestHelpers.GetDGSpecFromPackageSpecs(packageSpec),
new DependencyGraphCacheContext(),
new RestoreCommandProvidersCache(),
cacheContextModifier : _ => { },
sources : new SourceRepository[0],
parentId : Guid.Empty,
forceRestore : false,
isRestoreOriginalAction : true,
additionalMessages : null,
progressReporter : progressReporter.Object,
new TestLogger(),
CancellationToken.None);
// Assert
result.Should().HaveCount(1);
RestoreSummary restoreSummary = result[0];
restoreSummary.Success.Should().BeTrue();
restoreSummary.NoOpRestore.Should().BeFalse();
var assetsFilePath = Path.Combine(packageSpec.RestoreMetadata.OutputPath, LockFileFormat.AssetsFileName);
File.Exists(assetsFilePath).Should().BeTrue(because: $"{assetsFilePath}");
var propsFile = BuildAssetsUtils.GetMSBuildFilePath(packageSpec, BuildAssetsUtils.PropsExtension);
var targetsFile = BuildAssetsUtils.GetMSBuildFilePath(packageSpec, BuildAssetsUtils.TargetsExtension);
IReadOnlyList <string> expectedFileList = new string[] { assetsFilePath, propsFile, targetsFile };
var pathComparer = PathUtility.GetStringComparerBasedOnOS();
progressReporter.Verify(r =>
r.StartProjectUpdate(
It.Is <string>(e => e.Equals(packageSpec.FilePath)),
It.Is <IReadOnlyList <string> >(e => e.OrderedEquals(expectedFileList, (f) => f, pathComparer, pathComparer))),
Times.Once);
progressReporter.Verify(r =>
r.EndProjectUpdate(
It.Is <string>(e => e.Equals(packageSpec.FilePath)),
It.Is <IReadOnlyList <string> >(e => e.OrderedEquals(expectedFileList, (f) => f, pathComparer, pathComparer))),
Times.Once);
}
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredWithNoChangesFallbackFolder()
{
// Arrange
var projectName = "testproj";
using (var globalFolder = TestDirectory.Create())
using (var fallbackFolder = TestDirectory.Create())
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName);
var json = JObject.Parse(File.ReadAllText(projectConfig.FullName));
JsonConfigUtility.AddDependency(json, new NuGet.Packaging.Core.PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7")));
using (var writer = new StreamWriter(projectConfig.FullName))
{
writer.Write(json.ToString());
}
var sources = new List <SourceRepository>
{
Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/")
};
var projectTargetFramework = NuGetFramework.Parse("uap10.0");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName);
// Restore to the fallback folder
var solutionManager = new TestSolutionManager(false);
solutionManager.NuGetProjects.Add(project);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger, NullSettings.Instance);
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sources,
false,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
testLogger,
CancellationToken.None);
var packageFolders = new List <string> {
globalFolder, fallbackFolder
};
// Act
//var actual = await project.IsRestoreRequired(
// packageFolders.Select(p => new VersionFolderPathResolver(p)),
// new HashSet<PackageIdentity>(),
// restoreContext);
// Assert
//Assert.False(actual);
}
}
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredChangedSha512()
{
// Arrange
var projectName = "testproj";
using (var packagesFolder = TestDirectory.Create())
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName);
var json = JObject.Parse(File.ReadAllText(projectConfig.FullName));
JsonConfigUtility.AddDependency(json, new PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7")));
using (var writer = new StreamWriter(projectConfig.FullName))
{
writer.Write(json.ToString());
}
var sources = new List <SourceRepository> {
};
var testLogger = new TestLogger();
var settings = new Settings(rootFolder);
settings.SetValue(SettingsUtility.ConfigSection, "globalPackagesFolder", packagesFolder);
var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName);
var solutionManager = new TestSolutionManager(false);
solutionManager.NuGetProjects.Add(project);
var restoreContext = new DependencyGraphCacheContext(testLogger, settings);
var providersCache = new RestoreCommandProvidersCache();
var dgSpec1 = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext);
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
providersCache,
(c) => { },
sources,
false,
dgSpec1,
testLogger,
CancellationToken.None);
var dgSpec2 = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext);
var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
providersCache,
(c) => { },
sources,
false,
dgSpec2,
testLogger,
CancellationToken.None);
foreach (var restoreSummary in noOpRestoreSummaries)
{
Assert.True(restoreSummary.NoOpRestore);
}
var resolver = new VersionFolderPathResolver(packagesFolder);
var hashPath = resolver.GetHashPath("nuget.versioning", NuGetVersion.Parse("1.0.7"));
using (var writer = new StreamWriter(hashPath))
{
writer.Write("ANAWESOMELYWRONGHASH!!!");
}
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sources,
false,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
testLogger,
CancellationToken.None);
foreach (var restoreSummary in restoreSummaries)
{
Assert.True(restoreSummary.Success);
Assert.False(restoreSummary.NoOpRestore);
}
}
}
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredWithNoChanges()
{
// Arrange
var projectName = "testproj";
using (var packagesFolder = TestDirectory.Create())
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName);
var json = JObject.Parse(File.ReadAllText(projectConfig.FullName));
JsonConfigUtility.AddDependency(json, new NuGet.Packaging.Core.PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7")));
using (var writer = new StreamWriter(projectConfig.FullName))
{
writer.Write(json.ToString());
}
var sources = new List <SourceRepository>
{
Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/")
};
var projectTargetFramework = NuGetFramework.Parse("uap10.0");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName);
var effectiveGlobalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(NullSettings.Instance);
var solutionManager = new TestSolutionManager(false);
solutionManager.NuGetProjects.Add(project);
var testLogger = new TestLogger();
var settings = new Settings(rootFolder);
settings.SetValue(SettingsUtility.ConfigSection, "globalPackagesFolder", packagesFolder);
var providersCache = new RestoreCommandProvidersCache();
var restoreContext = new DependencyGraphCacheContext(testLogger, settings);
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
providersCache,
(c) => { },
sources,
false,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
testLogger,
CancellationToken.None);
var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
providersCache,
(c) => { },
sources,
false,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
testLogger,
CancellationToken.None);
foreach (var restoreSummary in noOpRestoreSummaries)
{
Assert.True(restoreSummary.NoOpRestore);
}
}
}
public async Task BuildIntegratedNuGetProject_IsRestoreNotRequiredWithFloatingVersion()
{
// Arrange
var projectName = "testproj";
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName);
var json = JObject.Parse(File.ReadAllText(projectConfig.FullName));
json.Add("dependencies", JObject.Parse("{ \"nuget.versioning\": \"1.0.*\" }"));
using (var writer = new StreamWriter(projectConfig.FullName))
{
writer.Write(json.ToString());
}
var sources = new List <SourceRepository>
{
Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/")
};
var projectTargetFramework = NuGetFramework.Parse("uap10.0");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var project = new ProjectJsonBuildIntegratedNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName, msBuildNuGetProjectSystem);
var effectiveGlobalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(NullSettings.Instance);
var solutionManager = new TestSolutionManager(false);
solutionManager.NuGetProjects.Add(project);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger);
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sources,
NullSettings.Instance,
testLogger,
CancellationToken.None);
// Act
var actual = await project.IsRestoreRequired(
new[] { new VersionFolderPathResolver(effectiveGlobalPackagesFolder) },
new HashSet <PackageIdentity>(),
restoreContext);
// Assert
Assert.False(actual);
}
}
public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_LockedMode()
{
using (var packageSource = TestDirectory.Create())
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(
new List <Configuration.PackageSource>()
{
new Configuration.PackageSource(packageSource.Path)
});
using (var testSolutionManager = new TestSolutionManager(true))
using (var randomProjectFolderPath = TestDirectory.Create())
{
var testSettings = PopulateSettingsWithSources(sourceRepositoryProvider, randomProjectFolderPath);
var testNuGetProjectContext = new TestNuGetProjectContext();
var deleteOnRestartManager = new TestDeleteOnRestartManager();
var nuGetPackageManager = new NuGetPackageManager(
sourceRepositoryProvider,
testSettings,
testSolutionManager,
deleteOnRestartManager);
var projectTargetFrameworkStr = "net45";
var fullProjectPath = Path.Combine(randomProjectFolderPath, "project1.csproj");
var projectNames = new ProjectNames(
fullName: fullProjectPath,
uniqueName: Path.GetFileName(fullProjectPath),
shortName: Path.GetFileNameWithoutExtension(fullProjectPath),
customUniqueName: Path.GetFileName(fullProjectPath));
var vsProjectAdapter = new TestVSProjectAdapter(
fullProjectPath,
projectNames,
projectTargetFrameworkStr,
restorePackagesWithLockFile: "true",
restoreLockedMode: true);
var projectServices = new TestProjectSystemServices();
projectServices.SetupInstalledPackages(
NuGetFramework.Parse(projectTargetFrameworkStr),
new LibraryDependency
{
LibraryRange = new LibraryRange(
"packageA",
VersionRange.Parse("1.*"),
LibraryDependencyTarget.Package)
});
var legacyPRProject = new LegacyPackageReferenceProject(
vsProjectAdapter,
Guid.NewGuid().ToString(),
projectServices,
_threadingService);
testSolutionManager.NuGetProjects.Add(legacyPRProject);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger, testSettings);
var packageContextA = new SimpleTestPackageContext("packageA", "1.0.0");
packageContextA.AddFile("lib/net45/a.dll");
SimpleTestPackageUtility.CreateOPCPackage(packageContextA, packageSource);
var packageContextB = new SimpleTestPackageContext("packageB", "1.0.0");
packageContextB.AddFile("lib/net45/b.dll");
SimpleTestPackageUtility.CreateOPCPackage(packageContextB, packageSource);
var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(testSolutionManager, restoreContext);
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
testSolutionManager,
dgSpec,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sourceRepositoryProvider.GetRepositories(),
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
foreach (var restoreSummary in restoreSummaries)
{
Assert.True(restoreSummary.Success);
Assert.False(restoreSummary.NoOpRestore);
}
Assert.True(File.Exists(Path.Combine(randomProjectFolderPath, "packages.lock.json")));
// install a new package
projectServices.SetupInstalledPackages(
NuGetFramework.Parse(projectTargetFrameworkStr),
new LibraryDependency
{
LibraryRange = new LibraryRange(
"packageA",
VersionRange.Parse("1.*"),
LibraryDependencyTarget.Package)
},
new LibraryDependency
{
LibraryRange = new LibraryRange(
"packageB",
VersionRange.Parse("1.0.0"),
LibraryDependencyTarget.Package)
});
// update the proeject with new ProjectService instance
restoreContext.PackageSpecCache.Clear();
dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(testSolutionManager, restoreContext);
// Act
restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
testSolutionManager,
dgSpec,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sourceRepositoryProvider.GetRepositories(),
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
// Assert
foreach (var restoreSummary in restoreSummaries)
{
Assert.False(restoreSummary.Success);
}
}
}
}
public async Task RestoreAsync_WithMinimalProjectAndAdditionalErrorMessage_WritesErrorsToAssetsFile()
{
// Arrange
var projectName = "testproj";
var logger = new TestLogger();
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var objFolder = projectFolder.CreateSubdirectory("obj");
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
var globalPackagesFolder = Path.Combine(rootFolder, "gpf");
var sources = new SourceRepository[0];
var restoreContext = new DependencyGraphCacheContext(logger, NullSettings.Instance);
var solutionManager = new Mock <ISolutionManager>();
var restoreCommandProvidersCache = new RestoreCommandProvidersCache();
// When a VS nomination results in an exception, we use this minimal DGSpec to do a restore.
var dgSpec = DependencyGraphSpecTestUtilities.CreateMinimalDependencyGraphSpec(msbuildProjectPath.FullName, objFolder.FullName);
dgSpec.AddRestore(dgSpec.Projects[0].FilePath);
// CpsPackageReferenceProject sets some additional properties, from settings, in GetPackageSpecsAndAdditionalMessages(...)
dgSpec.Projects[0].RestoreMetadata.PackagesPath = globalPackagesFolder;
// Having an "additional" error message is also critical
var restoreLogMessage = new RestoreLogMessage(LogLevel.Error, NuGetLogCode.NU1000, "Test error")
{
FilePath = msbuildProjectPath.FullName,
ProjectPath = msbuildProjectPath.FullName
};
var additionalMessages = new List <IAssetsLogMessage>()
{
AssetsLogMessage.Create(restoreLogMessage)
};
// Act
await DependencyGraphRestoreUtility.RestoreAsync(
dgSpec,
restoreContext,
restoreCommandProvidersCache,
cacheContextModifier : _ => { },
sources,
parentId : Guid.Empty,
forceRestore : false,
isRestoreOriginalAction : true,
additionalMessages,
progressReporter : null,
logger,
CancellationToken.None);
// Assert
var assetsFilePath = Path.Combine(objFolder.FullName, "project.assets.json");
Assert.True(File.Exists(assetsFilePath), "Assets file does not exist");
LockFile assetsFile = new LockFileFormat().Read(assetsFilePath);
IAssetsLogMessage actualMessage = Assert.Single(assetsFile.LogMessages);
Assert.Equal(restoreLogMessage.Level, actualMessage.Level);
Assert.Equal(restoreLogMessage.Code, actualMessage.Code);
Assert.Equal(restoreLogMessage.Message, actualMessage.Message);
}
}
public async Task RestoreAsync_WithProgressReporter_WithMultipleProjects_ProgressIsNotReportedForChangedProjetsOnly()
{
// Arrange
using var pathContext = new SimpleTestPathContext();
var settings = Settings.LoadDefaultSettings(pathContext.SolutionRoot);
var project1 = ProjectTestHelpers.GetPackageSpec(settings, projectName: "project1", rootPath: pathContext.SolutionRoot);
var project2 = ProjectTestHelpers.GetPackageSpec(settings, projectName: "project2", rootPath: pathContext.SolutionRoot);
var progressReporter = new Mock <IRestoreProgressReporter>();
// Pre-Conditions
IReadOnlyList <RestoreSummary> result = await DependencyGraphRestoreUtility.RestoreAsync(
ProjectTestHelpers.GetDGSpecFromPackageSpecs(project1, project2),
new DependencyGraphCacheContext(),
new RestoreCommandProvidersCache(),
cacheContextModifier : _ => { },
sources : new SourceRepository[0],
parentId : Guid.Empty,
forceRestore : false,
isRestoreOriginalAction : true,
additionalMessages : null,
progressReporter : progressReporter.Object,
new TestLogger(),
CancellationToken.None);
// Pre-Conditions
result.Should().HaveCount(2);
foreach (RestoreSummary restoreSummary in result)
{
restoreSummary.Success.Should().BeTrue();
restoreSummary.NoOpRestore.Should().BeFalse();
}
progressReporter.Verify(r =>
r.StartProjectUpdate(
It.Is <string>(e => e.Equals(project1.FilePath)),
It.IsAny <IReadOnlyList <string> >()),
Times.Once);
progressReporter.Verify(r =>
r.EndProjectUpdate(
It.Is <string>(e => e.Equals(project1.FilePath)),
It.IsAny <IReadOnlyList <string> >()),
Times.Once);
progressReporter.Verify(r =>
r.StartProjectUpdate(
It.Is <string>(e => e.Equals(project2.FilePath)),
It.IsAny <IReadOnlyList <string> >()),
Times.Once);
progressReporter.Verify(r =>
r.EndProjectUpdate(
It.Is <string>(e => e.Equals(project2.FilePath)),
It.IsAny <IReadOnlyList <string> >()),
Times.Once);
progressReporter.Verify(r =>
r.StartProjectUpdate(
It.IsAny <string>(),
It.IsAny <IReadOnlyList <string> >()),
Times.Exactly(2));
progressReporter.Verify(r =>
r.EndProjectUpdate(
It.IsAny <string>(),
It.IsAny <IReadOnlyList <string> >()),
Times.Exactly(2));
var secondaryProgressReporter = new Mock <IRestoreProgressReporter>();
// Act
result = await DependencyGraphRestoreUtility.RestoreAsync(
ProjectTestHelpers.GetDGSpecFromPackageSpecs(project1.WithTestProjectReference(project2), project2),
new DependencyGraphCacheContext(),
new RestoreCommandProvidersCache(),
cacheContextModifier : _ => { },
sources : new SourceRepository[0],
parentId : Guid.Empty,
forceRestore : false,
isRestoreOriginalAction : true,
additionalMessages : null,
progressReporter : secondaryProgressReporter.Object,
new TestLogger(),
CancellationToken.None);
// Assert
result.Should().HaveCount(2);
var project1Summary = result.Single(e => e.InputPath.Equals(project1.FilePath));
var project2Summary = result.Single(e => e.InputPath.Equals(project2.FilePath));
project1Summary.Success.Should().BeTrue();
project1Summary.NoOpRestore.Should().BeFalse();
// One no-op
project2Summary.Success.Should().BeTrue();
project2Summary.NoOpRestore.Should().BeTrue();
progressReporter.Verify(r =>
r.StartProjectUpdate(
It.Is <string>(e => e.Equals(project1.FilePath)),
It.IsAny <IReadOnlyList <string> >()),
Times.Once);
progressReporter.Verify(r =>
r.EndProjectUpdate(
It.Is <string>(e => e.Equals(project1.FilePath)),
It.IsAny <IReadOnlyList <string> >()),
Times.Once);
}
public async Task BuildIntegratedNuGetProject_IsRestoreNotRequiredWithFloatingVersion()
{
// Arrange
var projectName = "testproj";
using (var packagesFolder = TestDirectory.Create())
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName);
var json = JObject.Parse(File.ReadAllText(projectConfig.FullName));
json.Add("dependencies", JObject.Parse("{ \"nuget.versioning\": \"1.0.*\" }"));
using (var writer = new StreamWriter(projectConfig.FullName))
{
writer.Write(json.ToString());
}
var sources = new List <SourceRepository>
{
Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/")
};
var projectTargetFramework = NuGetFramework.Parse("uap10.0");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName);
var testLogger = new TestLogger();
var settings = new Settings(rootFolder);
settings.AddOrUpdate(ConfigurationConstants.Config, new AddItem("globalPackagesFolder", packagesFolder));
using (var solutionManager = new TestSolutionManager())
{
solutionManager.NuGetProjects.Add(project);
var restoreContext = new DependencyGraphCacheContext(testLogger, settings);
var providersCache = new RestoreCommandProvidersCache();
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
restoreContext,
providersCache,
(c) => { },
sources,
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
restoreContext,
providersCache,
(c) => { },
sources,
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
foreach (var restoreSummary in noOpRestoreSummaries)
{
Assert.True(restoreSummary.NoOpRestore);
}
}
}
}
public async Task BuildIntegratedRestoreUtility_RestoreToRelativePathGlobalPackagesFolder()
{
// Arrange
var projectName = "testproj";
using (var solutionManager = new TestSolutionManager())
{
var projectFolder = new DirectoryInfo(Path.Combine(solutionManager.SolutionDirectory, projectName));
projectFolder.Create();
var projectJson = new FileInfo(Path.Combine(projectFolder.FullName, "project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
File.WriteAllText(projectJson.FullName, BuildIntegrationTestUtility.ProjectJsonWithPackage);
var sources = new List <SourceRepository>
{
Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/")
};
var projectTargetFramework = NuGetFramework.Parse("uap10.0");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework,
new TestNuGetProjectContext());
var project = new ProjectJsonNuGetProject(projectJson.FullName, msbuildProjectPath.FullName);
var configContents = @"<?xml version=""1.0"" encoding=""utf-8""?>
<configuration>
<config>
<add key=""globalPackagesFolder"" value=""..\NuGetPackages"" />
</config>
<packageSources>
<add key=""nuget.org.v2"" value=""https://www.nuget.org/api/v2/"" />
</packageSources>
</configuration>";
var configLocation = solutionManager.NuGetConfigPath;
// delete the default config from the solution manager
if (File.Exists(configLocation))
{
File.Delete(configLocation);
}
File.WriteAllText(configLocation, configContents);
var settings = Settings.LoadSpecificSettings(solutionManager.SolutionDirectory, "NuGet.Config");
solutionManager.NuGetProjects.Add(project);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger, settings);
// Act
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sources,
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
// Assert
Assert.True(File.Exists(Path.Combine(projectFolder.FullName, "project.lock.json")));
var packagesFolder = Path.Combine(solutionManager.SolutionDirectory, @"..\NuGetPackages");
Assert.True(Directory.Exists(packagesFolder));
Assert.True(File.Exists(Path.Combine(
packagesFolder,
"EntityFramework",
"5.0.0",
"EntityFramework.5.0.0.nupkg")));
Assert.True(testLogger.Errors == 0, testLogger.ShowErrors());
}
}
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredChangedSha512()
{
// Arrange
var projectName = "testproj";
using (var solutionManager = new TestSolutionManager(false))
{
var projectFolder = new DirectoryInfo(Path.Combine(solutionManager.SolutionDirectory, projectName));
projectFolder.Create();
var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName);
var json = JObject.Parse(File.ReadAllText(projectConfig.FullName));
JsonConfigUtility.AddDependency(json, new PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7")));
using (var writer = new StreamWriter(projectConfig.FullName))
{
writer.Write(json.ToString());
}
var sources = new List <SourceRepository> {
};
var testLogger = new TestLogger();
var settings = Settings.LoadSpecificSettings(solutionManager.SolutionDirectory, "NuGet.Config");
var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName);
solutionManager.NuGetProjects.Add(project);
var restoreContext = new DependencyGraphCacheContext(testLogger, settings);
var providersCache = new RestoreCommandProvidersCache();
var dgSpec1 = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext);
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
dgSpec1,
restoreContext,
providersCache,
(c) => { },
sources,
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
var dgSpec2 = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext);
var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
dgSpec2,
restoreContext,
providersCache,
(c) => { },
sources,
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
foreach (var restoreSummary in noOpRestoreSummaries)
{
Assert.True(restoreSummary.NoOpRestore);
}
var resolver = new VersionFolderPathResolver(solutionManager.GlobalPackagesFolder);
var hashPath = resolver.GetHashPath("nuget.versioning", NuGetVersion.Parse("1.0.7"));
File.Delete(hashPath);
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sources,
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
foreach (var restoreSummary in restoreSummaries)
{
Assert.True(restoreSummary.Success);
Assert.False(restoreSummary.NoOpRestore);
}
var filePath = Path.Combine(
NuGetEnvironment.GetFolderPath(NuGetFolderPath.Temp),
"nuget-dg",
"nugetSpec.dg");
Assert.True(File.Exists(filePath));
}
}
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredMissingPackage()
{
// Arrange
var projectName = "testproj";
using (var solutionManager = new TestSolutionManager(false))
{
var projectFolder = new DirectoryInfo(Path.Combine(solutionManager.SolutionDirectory, projectName));
projectFolder.Create();
var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName);
var json = JObject.Parse(File.ReadAllText(projectConfig.FullName));
JsonConfigUtility.AddDependency(json, new NuGet.Packaging.Core.PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7")));
using (var writer = new StreamWriter(projectConfig.FullName))
{
writer.Write(json.ToString());
}
var sources = new List <SourceRepository> {
};
var projectTargetFramework = NuGetFramework.Parse("uap10.0");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName);
solutionManager.NuGetProjects.Add(project);
var testLogger = new TestLogger();
var settings = Settings.LoadSpecificSettings(solutionManager.SolutionDirectory, "NuGet.Config");
var restoreContext = new DependencyGraphCacheContext(testLogger, settings);
var providersCache = new RestoreCommandProvidersCache();
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
restoreContext,
providersCache,
(c) => { },
sources,
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
restoreContext,
providersCache,
(c) => { },
sources,
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
foreach (var restoreSummary in noOpRestoreSummaries)
{
Assert.True(restoreSummary.NoOpRestore);
}
var resolver = new VersionFolderPathResolver(solutionManager.GlobalPackagesFolder);
var pathToDelete = resolver.GetInstallPath("nuget.versioning", NuGetVersion.Parse("1.0.7"));
TestFileSystemUtility.DeleteRandomTestFolder(pathToDelete);
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sources,
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
foreach (var restoreSummary in restoreSummaries)
{
Assert.True(restoreSummary.Success);
Assert.False(restoreSummary.NoOpRestore);
}
}
}
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredChangedSha512()
{
// Arrange
var projectName = "testproj";
using (var packagesFolder = TestDirectory.Create())
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName);
var json = JObject.Parse(File.ReadAllText(projectConfig.FullName));
JsonConfigUtility.AddDependency(json, new PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7")));
using (var writer = new StreamWriter(projectConfig.FullName))
{
writer.Write(json.ToString());
}
var sources = new List <SourceRepository>
{
Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/")
};
var testLogger = new TestLogger();
var projectTargetFramework = NuGetFramework.Parse("uap10.0");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var project = new ProjectJsonBuildIntegratedNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName, msBuildNuGetProjectSystem);
var solutionManager = new TestSolutionManager(false);
solutionManager.NuGetProjects.Add(project);
var restoreContext = new DependencyGraphCacheContext(testLogger);
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sources,
packagesFolder,
NullSettings.Instance,
testLogger,
CancellationToken.None);
var resolver = new VersionFolderPathResolver(packagesFolder);
var hashPath = resolver.GetHashPath("nuget.versioning", NuGetVersion.Parse("1.0.7"));
using (var writer = new StreamWriter(hashPath))
{
writer.Write("ANAWESOMELYWRONGHASH!!!");
}
// Act
var actual = await project.IsRestoreRequired(
new[] { resolver },
new HashSet <PackageIdentity>(),
restoreContext);
// Assert
Assert.True(actual);
}
}
public async Task BuildIntegratedNuGetProject_RestoreFailed_PersistDGSpecFile()
{
// Arrange
var projectName = "testproj";
using (var packagesFolder = TestDirectory.Create())
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName);
var json = JObject.Parse(File.ReadAllText(projectConfig.FullName));
// invalid version for nuget.versioning package which will make this restore fail.
JsonConfigUtility.AddDependency(json, new PackageDependency("nuget.versioning", VersionRange.Parse("3000.0.0")));
using (var writer = new StreamWriter(projectConfig.FullName))
{
writer.Write(json.ToString());
}
var sources = new List <SourceRepository> {
};
var testLogger = new TestLogger();
var settings = new Settings(rootFolder);
settings.SetValue(SettingsUtility.ConfigSection, "globalPackagesFolder", packagesFolder);
var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName);
var solutionManager = new TestSolutionManager(false);
solutionManager.NuGetProjects.Add(project);
var restoreContext = new DependencyGraphCacheContext(testLogger, settings);
var providersCache = new RestoreCommandProvidersCache();
var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext);
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
providersCache,
(c) => { },
sources,
false,
dgSpec,
testLogger,
CancellationToken.None);
foreach (var restoreSummary in restoreSummaries)
{
Assert.False(restoreSummary.Success);
}
var filePath = Path.Combine(
NuGetEnvironment.GetFolderPath(NuGetFolderPath.Temp),
"nuget-dg",
"nugetSpec.dg");
Assert.True(File.Exists(filePath));
}
}
public async Task RestoreAsync_WithProgressReporter_WhenProjectNoOps_ProgressIsNotReported()
{
// Arrange
using var pathContext = new SimpleTestPathContext();
var settings = Settings.LoadDefaultSettings(pathContext.SolutionRoot);
var packageSpec = ProjectTestHelpers.GetPackageSpec(settings, projectName: "projectName", rootPath: pathContext.SolutionRoot);
var dgSpec = ProjectTestHelpers.GetDGSpecFromPackageSpecs(packageSpec);
var progressReporter = new Mock <IRestoreProgressReporter>();
// Pre-Conditions
IReadOnlyList <RestoreSummary> result = await DependencyGraphRestoreUtility.RestoreAsync(
dgSpec,
new DependencyGraphCacheContext(),
new RestoreCommandProvidersCache(),
cacheContextModifier : _ => { },
sources : new SourceRepository[0],
parentId : Guid.Empty,
forceRestore : false,
isRestoreOriginalAction : true,
additionalMessages : null,
progressReporter : progressReporter.Object,
new TestLogger(),
CancellationToken.None);
// Pre-Conditions
result.Should().HaveCount(1);
RestoreSummary restoreSummary = result[0];
restoreSummary.Success.Should().BeTrue();
restoreSummary.NoOpRestore.Should().BeFalse();
progressReporter.Verify(r =>
r.StartProjectUpdate(
It.IsAny <string>(),
It.IsAny <IReadOnlyList <string> >()),
Times.Once);
progressReporter.Verify(r =>
r.EndProjectUpdate(
It.IsAny <string>(),
It.IsAny <IReadOnlyList <string> >()),
Times.Once);
var noopProgressReporter = new Mock <IRestoreProgressReporter>();
// Act
result = await DependencyGraphRestoreUtility.RestoreAsync(
dgSpec,
new DependencyGraphCacheContext(),
new RestoreCommandProvidersCache(),
cacheContextModifier : _ => { },
sources : new SourceRepository[0],
parentId : Guid.Empty,
forceRestore : false,
isRestoreOriginalAction : true,
additionalMessages : null,
progressReporter : noopProgressReporter.Object,
new TestLogger(),
CancellationToken.None);
// Assert
result.Should().HaveCount(1);
restoreSummary = result[0];
restoreSummary.Success.Should().BeTrue();
restoreSummary.NoOpRestore.Should().BeTrue();
noopProgressReporter.Verify(r =>
r.StartProjectUpdate(
It.IsAny <string>(),
It.IsAny <IReadOnlyList <string> >()),
Times.Never);
noopProgressReporter.Verify(r =>
r.EndProjectUpdate(
It.IsAny <string>(),
It.IsAny <IReadOnlyList <string> >()),
Times.Never);
}
public async Task DependencyGraphRestoreUtility_NoopIsRestoreRequiredAsyncTest()
{
// Arrange
var projectName = "testproj";
var logger = new TestLogger();
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "testproj.project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName);
var projectTargetFramework = NuGetFramework.Parse("uap10.0");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework,
new TestNuGetProjectContext());
var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName);
var restoreContext = new DependencyGraphCacheContext(logger, NullSettings.Instance);
var projects = new List <IDependencyGraphProject>()
{
project
};
var solutionManager = new TestSolutionManager(false);
solutionManager.NuGetProjects.Add(project);
var sources = new[] {
Repository.Factory.GetVisualStudio(new PackageSource("https://www.nuget.org/api/v2/"))
};
// Act
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sources,
false,
await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
logger,
CancellationToken.None);
var pathContext = NuGetPathContext.Create(NullSettings.Instance);
//var oldHash = restoreContext.SolutionSpecHash;
//var newContext = new DependencyGraphCacheContext(logger, NullSettings.Instance);
//// Act
//var result = await DependencyGraphRestoreUtility.IsRestoreRequiredAsync(
// solutionManager,
// forceRestore: false,
// pathContext: pathContext,
// cacheContext: newContext,
// oldDependencyGraphSpecHash: oldHash);
//// Assert
//Assert.Equal(false, result);
Assert.Equal(0, logger.Errors);
Assert.Equal(0, logger.Warnings);
Assert.Equal(2, logger.MinimalMessages.Count);
}
}
public async Task BuildIntegratedRestoreUtility_IsRestoreRequired_DeferredProjectLoad()
{
// Arrange
var projectName = "testproj";
var project1Json = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
}
}
}";
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = Path.Combine(projectFolder.FullName, "project.json");
var projectPath = Path.Combine(projectFolder.FullName, $"{projectName}.csproj");
var packageSpec = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", projectConfig);
var metadata = new ProjectRestoreMetadata();
packageSpec.RestoreMetadata = metadata;
metadata.ProjectStyle = ProjectStyle.ProjectJson;
metadata.ProjectPath = projectPath;
metadata.ProjectJsonPath = packageSpec.FilePath;
metadata.ProjectName = packageSpec.Name;
metadata.ProjectUniqueName = projectPath;
foreach (var framework in packageSpec.TargetFrameworks.Select(e => e.FrameworkName))
{
metadata.TargetFrameworks.Add(new ProjectRestoreMetadataFrameworkInfo(framework));
}
var solutionManager = new TestSolutionManager(false);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger);
restoreContext.DeferredPackageSpecs.Add(packageSpec);
var pathContext = NuGetPathContext.Create(NullSettings.Instance);
var oldHash = restoreContext.SolutionSpecHash;
// Act
var result = await DependencyGraphRestoreUtility.IsRestoreRequiredAsync(
solutionManager,
forceRestore : false,
pathContext : pathContext,
cacheContext : restoreContext,
oldDependencyGraphSpecHash : oldHash);
// Assert
Assert.Equal(true, result);
Assert.Equal(0, testLogger.Errors);
Assert.Equal(0, testLogger.Warnings);
}
}
public async Task BuildIntegratedRestoreUtility_RestoreDeferredProjectLoad()
{
// Arrange
var projectName = "testproj";
var project1Json = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
""dependencies"": {
""packageA"": ""1.0.0""
}
}
}
}";
using (var packageSource = TestDirectory.Create())
using (var rootFolder = TestDirectory.Create())
{
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(
new List <PackageSource>()
{
new PackageSource(packageSource.Path)
});
var packageContext = new SimpleTestPackageContext("packageA");
packageContext.AddFile("lib/net45/a.dll");
SimpleTestPackageUtility.CreateOPCPackage(packageContext, packageSource);
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = Path.Combine(projectFolder.FullName, "project.json");
var projectPath = Path.Combine(projectFolder.FullName, $"{projectName}.csproj");
var packageSpec = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", projectConfig);
var metadata = new ProjectRestoreMetadata();
packageSpec.RestoreMetadata = metadata;
metadata.ProjectStyle = ProjectStyle.ProjectJson;
metadata.ProjectPath = projectPath;
metadata.ProjectJsonPath = packageSpec.FilePath;
metadata.ProjectName = packageSpec.Name;
metadata.ProjectUniqueName = projectPath;
foreach (var framework in packageSpec.TargetFrameworks.Select(e => e.FrameworkName))
{
metadata.TargetFrameworks.Add(new ProjectRestoreMetadataFrameworkInfo(framework));
}
var solutionManager = new TestSolutionManager(false);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger);
restoreContext.DeferredPackageSpecs.Add(packageSpec);
// Act
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sourceRepositoryProvider.GetRepositories(),
NullSettings.Instance,
testLogger,
CancellationToken.None);
// Assert
Assert.True(File.Exists(Path.Combine(projectFolder.FullName, "project.lock.json")));
Assert.True(testLogger.Errors == 0);
}
}
public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_GenerateLockFile()
{
using (var packageSource = TestDirectory.Create())
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(
new List <Configuration.PackageSource>()
{
new Configuration.PackageSource(packageSource.Path)
});
using (var testSolutionManager = new TestSolutionManager(true))
using (var randomProjectFolderPath = TestDirectory.Create())
{
var testSettings = PopulateSettingsWithSources(sourceRepositoryProvider, randomProjectFolderPath);
var testNuGetProjectContext = new TestNuGetProjectContext();
var deleteOnRestartManager = new TestDeleteOnRestartManager();
var nuGetPackageManager = new NuGetPackageManager(
sourceRepositoryProvider,
testSettings,
testSolutionManager,
deleteOnRestartManager);
// set up projects
var projectTargetFrameworkStr = "net45";
var fullProjectPathB = Path.Combine(randomProjectFolderPath, "ProjectB", "project2.csproj");
var projectNamesB = new ProjectNames(
fullName: fullProjectPathB,
uniqueName: Path.GetFileName(fullProjectPathB),
shortName: Path.GetFileNameWithoutExtension(fullProjectPathB),
customUniqueName: Path.GetFileName(fullProjectPathB));
var vsProjectAdapterB = new TestVSProjectAdapter(
fullProjectPathB,
projectNamesB,
projectTargetFrameworkStr);
var projectServicesB = new TestProjectSystemServices();
projectServicesB.SetupInstalledPackages(
NuGetFramework.Parse(projectTargetFrameworkStr),
new LibraryDependency
{
LibraryRange = new LibraryRange(
"packageB",
VersionRange.Parse("1.*"),
LibraryDependencyTarget.Package)
});
var legacyPRProjectB = new LegacyPackageReferenceProject(
vsProjectAdapterB,
Guid.NewGuid().ToString(),
projectServicesB,
_threadingService);
var projectPathA = Path.Combine(randomProjectFolderPath, "ProjectA");
var fullProjectPathA = Path.Combine(projectPathA, "project1.csproj");
var projectNamesA = new ProjectNames(
fullName: fullProjectPathA,
uniqueName: Path.GetFileName(fullProjectPathA),
shortName: Path.GetFileNameWithoutExtension(fullProjectPathA),
customUniqueName: Path.GetFileName(fullProjectPathA));
var vsProjectAdapterA = new TestVSProjectAdapter(
fullProjectPathA,
projectNamesA,
projectTargetFrameworkStr,
restorePackagesWithLockFile: "true");
var projectServicesA = new TestProjectSystemServices();
projectServicesA.SetupInstalledPackages(
NuGetFramework.Parse(projectTargetFrameworkStr),
new LibraryDependency
{
LibraryRange = new LibraryRange(
"packageA",
VersionRange.Parse("1.*"),
LibraryDependencyTarget.Package)
});
projectServicesA.SetupProjectDependencies(
new ProjectRestoreReference
{
ProjectUniqueName = fullProjectPathB,
ProjectPath = fullProjectPathB
});
var legacyPRProjectA = new LegacyPackageReferenceProject(
vsProjectAdapterA,
Guid.NewGuid().ToString(),
projectServicesA,
_threadingService);
testSolutionManager.NuGetProjects.Add(legacyPRProjectB);
testSolutionManager.NuGetProjects.Add(legacyPRProjectA);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger, testSettings);
var providersCache = new RestoreCommandProvidersCache();
var packageContextA = new SimpleTestPackageContext("packageA", "1.0.0");
packageContextA.AddFile("lib/net45/a.dll");
var packageContextB = new SimpleTestPackageContext("packageB", "1.0.0");
packageContextB.AddFile("lib/net45/b.dll");
var packages = new List <SimpleTestPackageContext>()
{
packageContextA, packageContextB
};
SimpleTestPackageUtility.CreateOPCPackages(packages, packageSource);
var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(testSolutionManager, restoreContext);
// Act
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
testSolutionManager,
dgSpec,
restoreContext,
providersCache,
(c) => { },
sourceRepositoryProvider.GetRepositories(),
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
// Assert
foreach (var restoreSummary in restoreSummaries)
{
Assert.True(restoreSummary.Success);
Assert.False(restoreSummary.NoOpRestore);
}
Assert.True(File.Exists(Path.Combine(projectPathA, "packages.lock.json")));
var lockFile = PackagesLockFileFormat.Read(Path.Combine(projectPathA, "packages.lock.json"));
Assert.Equal(1, lockFile.Targets.Count);
Assert.Equal(".NETFramework,Version=v4.5", lockFile.Targets[0].Name);
Assert.Equal(3, lockFile.Targets[0].Dependencies.Count);
Assert.Equal("packageA", lockFile.Targets[0].Dependencies[0].Id);
Assert.Equal(PackageDependencyType.Direct, lockFile.Targets[0].Dependencies[0].Type);
Assert.Equal("packageB", lockFile.Targets[0].Dependencies[1].Id);
Assert.Equal(PackageDependencyType.Transitive, lockFile.Targets[0].Dependencies[1].Type);
Assert.Equal("project2", lockFile.Targets[0].Dependencies[2].Id);
Assert.Equal(PackageDependencyType.Project, lockFile.Targets[0].Dependencies[2].Type);
}
}
}
private async Task RestorePackageSpecProjectsAsync(
List <IDependencyGraphProject> projects,
bool forceRestore,
bool isSolutionAvailable,
RestoreOperationSource restoreSource,
IntervalTracker intervalTracker,
CancellationToken token)
{
// Only continue if there are some build integrated type projects.
if (!(projects.Any(project => project is BuildIntegratedNuGetProject)))
{
return;
}
if (_packageRestoreConsent.IsGranted)
{
if (!isSolutionAvailable)
{
var globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(_settings);
if (!Path.IsPathRooted(globalPackagesFolder))
{
var message = string.Format(
CultureInfo.CurrentCulture,
Resources.RelativeGlobalPackagesFolder,
globalPackagesFolder);
await _logger.WriteLineAsync(VerbosityLevel.Quiet, message);
// Cannot restore packages since globalPackagesFolder is a relative path
// and the solution is not available
return;
}
}
DependencyGraphCacheContext cacheContext;
DependencyGraphSpec originalDgSpec;
DependencyGraphSpec dgSpec;
IReadOnlyList <IAssetsLogMessage> additionalMessages;
using (intervalTracker.Start(RestoreTelemetryEvent.SolutionDependencyGraphSpecCreation))
{
// Cache p2ps discovered from DTE
cacheContext = new DependencyGraphCacheContext(_logger, _settings);
var pathContext = NuGetPathContext.Create(_settings);
// Get full dg spec
(originalDgSpec, additionalMessages) = await DependencyGraphRestoreUtility.GetSolutionRestoreSpecAndAdditionalMessages(_solutionManager, cacheContext);
}
using (intervalTracker.Start(RestoreTelemetryEvent.SolutionUpToDateCheck))
{
// Run solution based up to date check.
var projectsNeedingRestore = _solutionUpToDateChecker.PerformUpToDateCheck(originalDgSpec, _logger).AsList();
var specialReferencesCount = originalDgSpec.Projects
.Where(x => x.RestoreMetadata.ProjectStyle != ProjectStyle.PackageReference && x.RestoreMetadata.ProjectStyle != ProjectStyle.PackagesConfig && x.RestoreMetadata.ProjectStyle != ProjectStyle.ProjectJson)
.Count();
dgSpec = originalDgSpec;
// Only use the optimization results if the restore is not `force`.
// Still run the optimization check anyways to prep the cache.
if (!forceRestore)
{
// Update the dg spec.
dgSpec = originalDgSpec.WithoutRestores();
foreach (var uniqueProjectId in projectsNeedingRestore)
{
dgSpec.AddRestore(uniqueProjectId); // Fill DGSpec copy only with restore-needed projects
}
// Calculate the number of up to date projects
_upToDateProjectCount = originalDgSpec.Restore.Count - specialReferencesCount - projectsNeedingRestore.Count;
_noOpProjectsCount = _upToDateProjectCount;
}
}
using (intervalTracker.Start(RestoreTelemetryEvent.PackageReferenceRestoreDuration))
{
// Avoid restoring if all the projects are up to date, or the solution does not have build integrated projects.
if (DependencyGraphRestoreUtility.IsRestoreRequired(dgSpec))
{
// NOTE: During restore for build integrated projects,
// We might show the dialog even if there are no packages to restore
// When both currentStep and totalSteps are 0, we get a marquee on the dialog
await _logger.RunWithProgressAsync(
async (l, _, t) =>
{
// Display the restore opt out message if it has not been shown yet
await l.WriteHeaderAsync();
var sources = _sourceRepositoryProvider
.GetRepositories()
.ToList();
var providerCache = new RestoreCommandProvidersCache();
Action <SourceCacheContext> cacheModifier = (cache) => { };
var isRestoreOriginalAction = true;
var isRestoreSucceeded = true;
IReadOnlyList <RestoreSummary> restoreSummaries = null;
try
{
restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
_solutionManager,
dgSpec,
cacheContext,
providerCache,
cacheModifier,
sources,
_nuGetProjectContext.OperationId,
forceRestore,
isRestoreOriginalAction,
additionalMessages,
l,
t);
_packageCount += restoreSummaries.Select(summary => summary.InstallCount).Sum();
isRestoreSucceeded = restoreSummaries.All(summary => summary.Success == true);
_noOpProjectsCount += restoreSummaries.Where(summary => summary.NoOpRestore == true).Count();
_solutionUpToDateChecker.SaveRestoreStatus(restoreSummaries);
}
catch
{
isRestoreSucceeded = false;
throw;
}
finally
{
if (isRestoreSucceeded)
{
if (_noOpProjectsCount < restoreSummaries.Count)
{
_status = NuGetOperationStatus.Succeeded;
}
else
{
_status = NuGetOperationStatus.NoOp;
}
}
else
{
_status = NuGetOperationStatus.Failed;
}
}
},
token);
}
}
}
else if (restoreSource == RestoreOperationSource.Explicit)
{
await _logger.ShowErrorAsync(Resources.PackageRefNotRestoredBecauseOfNoConsent);
}
}
public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_PackageShaValidationFailed()
{
using (var packageSource = TestDirectory.Create())
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(
new List <Configuration.PackageSource>()
{
new Configuration.PackageSource(packageSource.Path)
});
using (var testSolutionManager = new TestSolutionManager(true))
using (var randomProjectFolderPath = TestDirectory.Create())
{
var testSettings = PopulateSettingsWithSources(sourceRepositoryProvider, randomProjectFolderPath);
var testNuGetProjectContext = new TestNuGetProjectContext();
var deleteOnRestartManager = new TestDeleteOnRestartManager();
var nuGetPackageManager = new NuGetPackageManager(
sourceRepositoryProvider,
testSettings,
testSolutionManager,
deleteOnRestartManager);
var projectTargetFrameworkStr = "net45";
var fullProjectPath = Path.Combine(randomProjectFolderPath, "project1.csproj");
var projectNames = new ProjectNames(
fullName: fullProjectPath,
uniqueName: Path.GetFileName(fullProjectPath),
shortName: Path.GetFileNameWithoutExtension(fullProjectPath),
customUniqueName: Path.GetFileName(fullProjectPath));
var vsProjectAdapter = new TestVSProjectAdapter(
fullProjectPath,
projectNames,
projectTargetFrameworkStr);
var projectServices = new TestProjectSystemServices();
projectServices.SetupInstalledPackages(
NuGetFramework.Parse(projectTargetFrameworkStr),
new LibraryDependency
{
LibraryRange = new LibraryRange(
"packageA",
VersionRange.Parse("1.*"),
LibraryDependencyTarget.Package)
});
var legacyPRProject = new LegacyPackageReferenceProject(
vsProjectAdapter,
Guid.NewGuid().ToString(),
projectServices,
_threadingService);
testSolutionManager.NuGetProjects.Add(legacyPRProject);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger, testSettings);
var packageContext = new SimpleTestPackageContext("packageA", "1.0.0");
packageContext.AddFile("lib/net45/a.dll");
SimpleTestPackageUtility.CreateOPCPackage(packageContext, packageSource);
var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(testSolutionManager, restoreContext);
var projectLockFilePath = Path.Combine(randomProjectFolderPath, "packages.project1.lock.json");
File.Create(projectLockFilePath).Close();
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
testSolutionManager,
dgSpec,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sourceRepositoryProvider.GetRepositories(),
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
foreach (var restoreSummary in restoreSummaries)
{
Assert.True(restoreSummary.Success);
Assert.False(restoreSummary.NoOpRestore);
}
Assert.True(File.Exists(projectLockFilePath));
// delete existing restore output files
File.Delete(Path.Combine(vsProjectAdapter.MSBuildProjectExtensionsPath, "project.assets.json"));
File.Delete(Path.Combine(vsProjectAdapter.MSBuildProjectExtensionsPath, "project1.csproj.nuget.cache"));
// clean packages folder
var packagesFolder = Path.Combine(randomProjectFolderPath, "packages");
Directory.Delete(packagesFolder, true);
Directory.CreateDirectory(packagesFolder);
// add a new package
var newPackageContext = new SimpleTestPackageContext("packageA", "1.0.0");
newPackageContext.AddFile("lib/net45/a1.dll");
SimpleTestPackageUtility.CreateOPCPackage(newPackageContext, packageSource);
// Act
restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
testSolutionManager,
dgSpec,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sourceRepositoryProvider.GetRepositories(),
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
// Assert
foreach (var restoreSummary in restoreSummaries)
{
Assert.False(restoreSummary.Success);
Assert.True(restoreSummary.Errors.Count > 0);
Assert.NotNull(restoreSummary.Errors.FirstOrDefault(message => (message as RestoreLogMessage).Code == NuGetLogCode.NU1403));
}
}
}
}
private async Task RestorePackageSpecProjectsAsync(
List <IDependencyGraphProject> projects,
bool forceRestore,
bool isSolutionAvailable,
IReadOnlyList <PackageSpec> packageSpecs,
CancellationToken token)
{
// Only continue if there are some build integrated type projects.
if (!(projects.Any(project => project is BuildIntegratedNuGetProject) ||
packageSpecs.Any(project => IsProjectBuildIntegrated(project))))
{
return;
}
if (IsConsentGranted(_settings))
{
if (!isSolutionAvailable)
{
var globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(_settings);
if (!Path.IsPathRooted(globalPackagesFolder))
{
await _logger.DoAsync((l, _) =>
{
var message = string.Format(
CultureInfo.CurrentCulture,
Resources.RelativeGlobalPackagesFolder,
globalPackagesFolder);
l.WriteLine(VerbosityLevel.Quiet, message);
});
// Cannot restore packages since globalPackagesFolder is a relative path
// and the solution is not available
return;
}
}
// Cache p2ps discovered from DTE
var cacheContext = new DependencyGraphCacheContext(_logger);
var pathContext = NuGetPathContext.Create(_settings);
// add deferred projects package spec in cacheContext packageSpecCache
cacheContext.DeferredPackageSpecs.AddRange(packageSpecs);
var isRestoreRequired = await DependencyGraphRestoreUtility.IsRestoreRequiredAsync(
_solutionManager,
forceRestore,
pathContext,
cacheContext,
_dependencyGraphProjectCacheHash);
// No-op all project closures are up to date and all packages exist on disk.
if (isRestoreRequired)
{
// Save the project between operations.
_dependencyGraphProjectCacheHash = cacheContext.SolutionSpecHash;
// NOTE: During restore for build integrated projects,
// We might show the dialog even if there are no packages to restore
// When both currentStep and totalSteps are 0, we get a marquee on the dialog
await _logger.RunWithProgressAsync(
async (l, _, t) =>
{
// Display the restore opt out message if it has not been shown yet
await l.WriteHeaderAsync();
var sources = _sourceRepositoryProvider
.GetRepositories()
.ToList();
var providerCache = new RestoreCommandProvidersCache();
Action <SourceCacheContext> cacheModifier = (cache) => { };
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
_solutionManager,
cacheContext,
providerCache,
cacheModifier,
sources,
_settings,
l,
t);
_packageCount += restoreSummaries.Select(summary => summary.InstallCount).Sum();
var isRestoreFailed = restoreSummaries.Any(summary => summary.Success == false);
if (isRestoreFailed)
{
_status = NuGetOperationStatus.Failed;
}
},
token);
}
}
}
private async Task RestorePackageSpecProjectsAsync(
List <IDependencyGraphProject> projects,
bool forceRestore,
bool isSolutionAvailable,
RestoreOperationSource restoreSource,
CancellationToken token)
{
// Only continue if there are some build integrated type projects.
if (!(projects.Any(project => project is BuildIntegratedNuGetProject)))
{
return;
}
if (_packageRestoreConsent.IsGranted)
{
if (!isSolutionAvailable)
{
var globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(_settings);
if (!Path.IsPathRooted(globalPackagesFolder))
{
await _logger.DoAsync((l, _) =>
{
var message = string.Format(
CultureInfo.CurrentCulture,
Resources.RelativeGlobalPackagesFolder,
globalPackagesFolder);
l.WriteLine(VerbosityLevel.Quiet, message);
});
// Cannot restore packages since globalPackagesFolder is a relative path
// and the solution is not available
return;
}
}
// Cache p2ps discovered from DTE
var cacheContext = new DependencyGraphCacheContext(_logger, _settings);
var pathContext = NuGetPathContext.Create(_settings);
// Get full dg spec
// TODO: pass this down instead of creating it twice.
var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(_solutionManager, cacheContext);
// Avoid restoring solutions with zero potential PackageReference projects.
if (DependencyGraphRestoreUtility.IsRestoreRequired(dgSpec))
{
// NOTE: During restore for build integrated projects,
// We might show the dialog even if there are no packages to restore
// When both currentStep and totalSteps are 0, we get a marquee on the dialog
await _logger.RunWithProgressAsync(
async (l, _, t) =>
{
// Display the restore opt out message if it has not been shown yet
await l.WriteHeaderAsync();
var sources = _sourceRepositoryProvider
.GetRepositories()
.ToList();
var providerCache = new RestoreCommandProvidersCache();
Action <SourceCacheContext> cacheModifier = (cache) => { };
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
_solutionManager,
cacheContext,
providerCache,
cacheModifier,
sources,
forceRestore,
dgSpec,
l,
t);
_packageCount += restoreSummaries.Select(summary => summary.InstallCount).Sum();
var isRestoreFailed = restoreSummaries.Any(summary => summary.Success == false);
_noOpProjectsCount = restoreSummaries.Where(summary => summary.NoOpRestore == true).Count();
if (isRestoreFailed)
{
_status = NuGetOperationStatus.Failed;
}
else if (_noOpProjectsCount < restoreSummaries.Count)
{
_status = NuGetOperationStatus.Succeeded;
}
},
token);
}
}
else if (restoreSource == RestoreOperationSource.Explicit)
{
// Log an error when restore is disabled and user explicitly restore.
await _logger.DoAsync((l, _) =>
{
l.ShowError(Resources.PackageRefNotRestoredBecauseOfNoConsent);
});
}
}
public async Task BuildIntegratedRestoreUtility_RestoreToRelativePathGlobalPackagesFolder()
{
// Arrange
var projectName = "testproj";
using (var rootFolder = TestDirectory.Create())
using (var configFolder = TestDirectory.Create())
using (var solutionFolderParent = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json"));
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
File.WriteAllText(projectConfig.FullName, BuildIntegrationTestUtility.ProjectJsonWithPackage);
var sources = new List <SourceRepository>
{
Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/")
};
var projectTargetFramework = NuGetFramework.Parse("uap10.0");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework,
new TestNuGetProjectContext());
var project = new ProjectJsonBuildIntegratedNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName, msBuildNuGetProjectSystem);
var configContents = @"<?xml version=""1.0"" encoding=""utf-8""?>
<configuration>
<config>
<add key=""globalPackagesFolder"" value=""..\NuGetPackages"" />
</config>
</configuration>";
var configSubFolder = Path.Combine(configFolder, "sub");
Directory.CreateDirectory(configSubFolder);
File.WriteAllText(Path.Combine(configFolder, "sub", "nuget.config"), configContents);
var settings = new Configuration.Settings(configSubFolder);
var solutionFolder = new DirectoryInfo(Path.Combine(solutionFolderParent, "solutionFolder"));
solutionFolder.Create();
var solutionManager = new TestSolutionManager(false);
solutionManager.NuGetProjects.Add(project);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger);
// Act
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sources,
settings,
testLogger,
CancellationToken.None);
// Assert
Assert.True(File.Exists(Path.Combine(projectFolder.FullName, "project.lock.json")));
var packagesFolder = Path.Combine(configFolder, "NuGetPackages");
Assert.True(Directory.Exists(packagesFolder));
Assert.True(File.Exists(Path.Combine(
packagesFolder,
"EntityFramework",
"5.0.0",
"EntityFramework.5.0.0.nupkg")));
Assert.True(testLogger.Errors == 0, testLogger.ShowErrors());
}
}
