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 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 async Task RestorePackages(
IEnumerable <BuildIntegratedNuGetProject> projects,
CancellationToken cancellationToken)
{
var spec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, context);
var now = DateTime.UtcNow;
Action <SourceCacheContext> cacheContextModifier = c => c.MaxAge = now;
bool forceRestore = false;
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
context,
new RestoreCommandProvidersCache(),
cacheContextModifier,
sourceRepositories,
Guid.NewGuid(),
forceRestore,
spec,
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 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 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));
}
}
}
}
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 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);
}
}
}
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_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 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 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 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);
}
}
}
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 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);
}
}
}
}