public void TestBuildIntegratedNuGetPackageSpecNameMatchesFilePath()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
using (var randomTestPackageSourcePath = TestFileSystemUtility.CreateRandomTestFolder())
using (var randomPackagesFolderPath = TestFileSystemUtility.CreateRandomTestFolder())
using (var randomProjectFolderPath = TestFileSystemUtility.CreateRandomTestFolder())
{
var randomConfig = Path.Combine(randomProjectFolderPath, "project.json");
var token = CancellationToken.None;
CreateConfigJson(randomConfig);
var projectTargetFramework = NuGetFramework.Parse("netcore50");
var testNuGetProjectContext = new TestNuGetProjectContext();
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(
projectTargetFramework,
testNuGetProjectContext,
randomProjectFolderPath,
"msbuildName");
var projectFilePath = Path.Combine(randomProjectFolderPath, "fileName.csproj");
var buildIntegratedProject = new BuildIntegratedNuGetProject(randomConfig, projectFilePath, msBuildNuGetProjectSystem);
// Assert
Assert.Equal(projectFilePath, buildIntegratedProject.MSBuildProjectPath);
Assert.Equal("fileName", buildIntegratedProject.ProjectName);
Assert.Equal("fileName", buildIntegratedProject.PackageSpec.Name);
}
}
private async Task <IEnumerable <NuGetProjectAction> > PacManCleanInstall(SourceRepositoryProvider sourceRepositoryProvider, PackageIdentity target)
{
// Arrange
using (var testSolutionManager = new TestSolutionManager())
using (var randomPackagesConfigFolderPath = TestDirectory.Create())
{
var testSettings = NullSettings.Instance;
var token = CancellationToken.None;
var deleteOnRestartManger = new TestDeleteOnRestartManager();
var nuGetPackageManager = new NuGetPackageManager(
sourceRepositoryProvider,
testSettings,
testSolutionManager,
deleteOnRestartManger);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config");
var projectTargetFramework = NuGetFramework.Parse("net45");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigFolderPath);
// Act
var nugetProjectActions = await nuGetPackageManager.PreviewInstallPackageAsync(msBuildNuGetProject, target,
new ResolutionContext(), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token);
return(nugetProjectActions);
}
}
public async Task TestBuildIntegratedNuGetPackageSpecNameMatchesFilePath()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
using (var randomTestPackageSourcePath = TestDirectory.Create())
using (var randomPackagesFolderPath = TestDirectory.Create())
using (var randomProjectFolderPath = TestDirectory.Create())
{
var randomConfig = Path.Combine(randomProjectFolderPath, "project.json");
var token = CancellationToken.None;
CreateConfigJson(randomConfig);
var projectTargetFramework = NuGetFramework.Parse("netcore50");
var testNuGetProjectContext = new TestNuGetProjectContext();
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(
projectTargetFramework,
testNuGetProjectContext,
randomProjectFolderPath,
"msbuildName");
var projectFilePath = Path.Combine(randomProjectFolderPath, "fileName.csproj");
var buildIntegratedProject = new ProjectJsonNuGetProject(randomConfig, projectFilePath);
var spec = await buildIntegratedProject.GetPackageSpecsAsync(new DependencyGraphCacheContext());
// Assert
Assert.Equal(projectFilePath, buildIntegratedProject.MSBuildProjectPath);
Assert.Equal("fileName", buildIntegratedProject.ProjectName);
Assert.Equal("fileName", spec.Single().Name);
}
}
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 TestBuildIntegratedNuGetProjectUninstallAllPackages()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
var packageIdentity2 = new PackageIdentity("packageB", new NuGetVersion("1.0.0"));
using (var randomTestPackageSourcePath = TestDirectory.Create())
using (var randomPackagesFolderPath = TestDirectory.Create())
using (var randomProjectFolderPath = TestDirectory.Create())
{
var randomConfig = Path.Combine(randomProjectFolderPath, "project.json");
var token = CancellationToken.None;
CreateConfigJson(randomConfig);
var projectTargetFramework = NuGetFramework.Parse("netcore50");
var testNuGetProjectContext = new TestNuGetProjectContext();
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, testNuGetProjectContext, randomProjectFolderPath);
var projectFilePath = Path.Combine(randomProjectFolderPath, $"{msBuildNuGetProjectSystem.ProjectName}.csproj");
var buildIntegratedProject = new ProjectJsonNuGetProject(randomConfig, projectFilePath);
var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyContentPackage(randomTestPackageSourcePath,
packageIdentity.Id, packageIdentity.Version.ToNormalizedString());
var packageFileInfo2 = TestPackagesGroupedByFolder.GetLegacyContentPackage(randomTestPackageSourcePath,
packageIdentity.Id, packageIdentity.Version.ToNormalizedString());
using (var packageStream = GetDownloadResourceResult(packageFileInfo))
{
await buildIntegratedProject.InstallPackageAsync(
packageIdentity.Id,
new VersionRange(packageIdentity.Version),
testNuGetProjectContext,
installationContext : null,
token : token);
await buildIntegratedProject.InstallPackageAsync(
packageIdentity2.Id,
new VersionRange(packageIdentity2.Version),
testNuGetProjectContext,
installationContext : null,
token : token);
// Act
await buildIntegratedProject.UninstallPackageAsync(packageIdentity2, new TestNuGetProjectContext(), CancellationToken.None);
await buildIntegratedProject.UninstallPackageAsync(packageIdentity, new TestNuGetProjectContext(), CancellationToken.None);
}
// Assert
// Check that the packages.config file exists after the installation
Assert.True(File.Exists(randomConfig));
// Check the number of packages and packages returned by project after the installation
var installedPackages = (await buildIntegratedProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(0, installedPackages.Count);
}
}
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 BuildIntegratedNuGetProject_GetPackageSpec_UAPWithImports()
{
// Arrange
var configJson = @"
{
""dependencies"": {
},
""frameworks"": {
""uap10.0"": {
""imports"": ""netstandard1.3"",
""warn"": false
}
}
}";
using (var randomProjectFolderPath = TestDirectory.Create())
{
var projectJsonPath = Path.Combine(randomProjectFolderPath, "project.json");
File.WriteAllText(projectJsonPath, configJson);
var FallbackTargetFramework = NuGetFramework.Parse("netstandard1.3");
var projectTargetFramework = NuGetFramework.Parse("uap10.0");
var testNuGetProjectContext = new TestNuGetProjectContext();
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, testNuGetProjectContext, randomProjectFolderPath);
var projectFilePath = Path.Combine(randomProjectFolderPath, $"{msBuildNuGetProjectSystem.ProjectName}.csproj");
var buildIntegratedProject = new ProjectJsonNuGetProject(projectJsonPath, projectFilePath);
var referenceContext = new DependencyGraphCacheContext(new TestLogger(), NullSettings.Instance);
// Act
var actual = (await buildIntegratedProject.GetPackageSpecsAsync(referenceContext)).SingleOrDefault();
// Assert
Assert.NotNull(actual);
Assert.Equal(msBuildNuGetProjectSystem.ProjectName, actual.Name);
Assert.Equal(projectJsonPath, actual.FilePath);
Assert.NotNull(actual.RestoreMetadata);
Assert.Equal(ProjectStyle.ProjectJson, actual.RestoreMetadata.ProjectStyle);
Assert.Equal(projectFilePath, actual.RestoreMetadata.ProjectPath);
Assert.Equal(msBuildNuGetProjectSystem.ProjectName, actual.RestoreMetadata.ProjectName);
Assert.Equal(projectFilePath, actual.RestoreMetadata.ProjectUniqueName);
Assert.Equal(1, actual.TargetFrameworks.Count);
Assert.Equal(projectTargetFramework, actual.TargetFrameworks[0].FrameworkName);
Assert.Equal(1, actual.TargetFrameworks[0].Imports.Count);
Assert.Equal(FallbackTargetFramework, actual.TargetFrameworks[0].Imports[0]);
Assert.Empty(actual.Dependencies);
Assert.Empty(actual.TargetFrameworks[0].Dependencies);
Assert.Empty(actual.RestoreMetadata.TargetFrameworks.SelectMany(e => e.ProjectReferences));
}
}
public async Task GetInstalledPackagesAsync_WhenProjectReturnsNullPackageReference_NullIsRemoved()
{
const string projectName = "a";
string projectId = Guid.NewGuid().ToString();
using (TestDirectory testDirectory = TestDirectory.Create())
{
Initialize();
string projectFullPath = Path.Combine(testDirectory.Path, $"{projectName}.csproj");
NuGetFramework targetFramework = NuGetFramework.Parse("net46");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(targetFramework, new TestNuGetProjectContext());
var project = new TestMSBuildNuGetProject(msBuildNuGetProjectSystem, testDirectory.Path, projectFullPath, projectId);
var packageReference = new PackageReference(
new PackageIdentity(id: "b", NuGetVersion.Parse("1.0.0")),
targetFramework);
project.InstalledPackageReferences = Task.FromResult <IEnumerable <PackageReference> >(new[]
{
null,
packageReference
});
_solutionManager.NuGetProjects.Add(project);
var telemetrySession = new Mock <ITelemetrySession>();
var telemetryEvents = new ConcurrentQueue <TelemetryEvent>();
telemetrySession
.Setup(x => x.PostEvent(It.IsAny <TelemetryEvent>()))
.Callback <TelemetryEvent>(x => telemetryEvents.Enqueue(x));
TelemetryActivity.NuGetTelemetryService = new NuGetVSTelemetryService(telemetrySession.Object);
IReadOnlyCollection <IPackageReferenceContextInfo> packages = await _projectManager.GetInstalledPackagesAsync(
new[] { projectId },
CancellationToken.None);
Assert.Equal(1, packages.Count);
IPackageReferenceContextInfo expected = PackageReferenceContextInfo.Create(packageReference);
IPackageReferenceContextInfo actual = packages.Single();
Assert.Equal(expected.AllowedVersions, actual.AllowedVersions);
Assert.Equal(expected.Framework, actual.Framework);
Assert.Equal(expected.Identity, actual.Identity);
Assert.Equal(expected.IsAutoReferenced, actual.IsAutoReferenced);
Assert.Equal(expected.IsDevelopmentDependency, actual.IsDevelopmentDependency);
Assert.Equal(expected.IsUserInstalled, actual.IsUserInstalled);
Assert.Equal(1, telemetryEvents.Count);
}
}
public async Task UnzippedPackageInstall_Basic()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
using (var testSolutionManager = new TestSolutionManager(true))
using (var randomPackagesConfigFolderPath = TestDirectory.Create())
{
var testSettings = new Configuration.NullSettings();
var deleteOnRestartManager = new TestDeleteOnRestartManager();
var nuGetPackageManager = new NuGetPackageManager(
sourceRepositoryProvider,
testSettings,
testSolutionManager,
deleteOnRestartManager);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config");
var token = CancellationToken.None;
var projectTargetFramework = NuGetFramework.Parse("net45");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigFolderPath);
var packageIdentity = NoDependencyLibPackages[0];
// Pre-Assert
// Check that the packages.config file does not exist
Assert.False(File.Exists(randomPackagesConfigPath));
// Check that there are no packages returned by PackagesConfigProject
var packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(0, packagesInPackagesConfig.Count);
Assert.Equal(0, msBuildNuGetProjectSystem.References.Count);
// Act
await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, packageIdentity,
new ResolutionContext(), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
// Check that the packages.config file exists after the installation
Assert.True(File.Exists(randomPackagesConfigPath));
// Check the number of packages and packages returned by PackagesConfigProject after the installation
packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(1, packagesInPackagesConfig.Count);
Assert.Equal(packageIdentity, packagesInPackagesConfig[0].PackageIdentity);
Assert.Equal(projectTargetFramework, packagesInPackagesConfig[0].TargetFramework);
}
}
public void GetPackagesLockFilePath_PackagesLockJson()
{
// Arrange
var projectName = "testproj";
var logger = new TestLogger();
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
var targetFramework = NuGetFramework.Parse("net46");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(targetFramework, new TestNuGetProjectContext(), projectFolder.FullName);
var project = new TestMSBuildNuGetProject(msBuildNuGetProjectSystem, rootFolder, projectFolder.FullName);
// Act
var lockFile = PackagesConfigLockFileUtility.GetPackagesLockFilePath(project);
// Assert
Assert.Equal(Path.Combine(projectFolder.FullName, "packages.lock.json"), lockFile);
}
}
public void GetPackagesLockFilePath_MsbuildProperty()
{
// Arrage
var projectName = "testproj";
var logger = new TestLogger();
var expected = "somewhere\\my.lock.json";
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
var targetFramework = NuGetFramework.Parse("net46");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(targetFramework, new TestNuGetProjectContext(), projectFolder.FullName);
var project = new TestMSBuildNuGetProject(msBuildNuGetProjectSystem, rootFolder, projectFolder.FullName);
msBuildNuGetProjectSystem.SetPropertyValue("NuGetLockFilePath", expected);
// Act
var lockFile = PackagesConfigLockFileUtility.GetPackagesLockFilePath(project);
// Assert
Assert.Equal(Path.Combine(projectFolder.FullName, expected), lockFile);
}
}
public async Task BuildIntegratedNuGetProject_GetPackageSpecForRestore_NoReferences()
{
// Arrange
using (var randomProjectFolderPath = TestDirectory.Create())
{
var projectJsonPath = Path.Combine(randomProjectFolderPath, "project.json");
CreateConfigJson(projectJsonPath);
var projectTargetFramework = NuGetFramework.Parse("netcore50");
var testNuGetProjectContext = new TestNuGetProjectContext();
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, testNuGetProjectContext, randomProjectFolderPath);
var projectFilePath = Path.Combine(randomProjectFolderPath, $"{msBuildNuGetProjectSystem.ProjectName}.csproj");
var buildIntegratedProject = new ProjectJsonNuGetProject(projectJsonPath, projectFilePath);
var referenceContext = new DependencyGraphCacheContext(new TestLogger(), NullSettings.Instance);
// Act
var actual = (await buildIntegratedProject.GetPackageSpecsAsync(referenceContext)).SingleOrDefault();
// Assert
Assert.NotNull(actual);
Assert.Equal(msBuildNuGetProjectSystem.ProjectName, actual.Name);
Assert.Equal(projectJsonPath, actual.FilePath);
Assert.NotNull(actual.RestoreMetadata);
Assert.Equal(ProjectStyle.ProjectJson, actual.RestoreMetadata.ProjectStyle);
Assert.Equal(projectFilePath, actual.RestoreMetadata.ProjectPath);
Assert.Equal(msBuildNuGetProjectSystem.ProjectName, actual.RestoreMetadata.ProjectName);
Assert.Equal(projectFilePath, actual.RestoreMetadata.ProjectUniqueName);
Assert.Equal(1, actual.TargetFrameworks.Count);
Assert.Equal(projectTargetFramework, actual.TargetFrameworks[0].FrameworkName);
Assert.Empty(actual.TargetFrameworks[0].Imports);
Assert.Empty(actual.Dependencies);
Assert.Empty(actual.TargetFrameworks[0].Dependencies);
Assert.Empty(actual.RestoreMetadata.TargetFrameworks.SelectMany(e => e.ProjectReferences));
}
}
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 GetInstallActionsAsync_WithPackagesConfigProject_WhenUpdatingPackage_ReturnsCorrectActions()
{
const string projectName = "a";
string projectId = Guid.NewGuid().ToString();
var projectSystemCache = new ProjectSystemCache();
using (TestDirectory testDirectory = TestDirectory.Create())
{
var packageV1 = new SimpleTestPackageContext(packageId: "b", version: "1.0.0");
var packageV2 = new SimpleTestPackageContext(packageV1.Id, version: "2.0.0");
string packageSourceDirectoryPath = Path.Combine(testDirectory, "packageSource");
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
packageSourceDirectoryPath,
PackageSaveMode.Defaultv3,
packageV1,
packageV2);
var packageSource = new PackageSource(packageSourceDirectoryPath);
var packageSources = new List <PackageSource>()
{
packageSource
};
Initialize(packageSources);
string projectFullPath = Path.Combine(testDirectory.Path, $"{projectName}.csproj");
NuGetFramework targetFramework = NuGetFramework.Parse("net46");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(targetFramework, new TestNuGetProjectContext());
var project = new TestMSBuildNuGetProject(msBuildNuGetProjectSystem, testDirectory.Path, projectFullPath, projectId);
_solutionManager.NuGetProjects.Add(project);
string[] projectIds = new[] { projectId };
string[] packageSourceNames = new[] { packageSource.Name };
await PerformOperationAsync(async (projectManager) =>
{
IReadOnlyList <ProjectAction> actions = await projectManager.GetInstallActionsAsync(
projectIds,
packageV1.Identity,
VersionConstraints.None,
includePrelease: true,
DependencyBehavior.Lowest,
packageSourceNames,
CancellationToken.None);
Assert.NotEmpty(actions);
Assert.Equal(1, actions.Count);
ProjectAction action = actions[0];
Assert.Equal(packageV1.Identity, action.PackageIdentity);
Assert.Equal(NuGetProjectActionType.Install, action.ProjectActionType);
Assert.Equal(projectId, action.ProjectId);
Assert.Empty(action.ImplicitActions);
await projectManager.ExecuteActionsAsync(actions, CancellationToken.None);
});
await PerformOperationAsync(async (projectManager) =>
{
IReadOnlyList <ProjectAction> actions = await projectManager.GetInstallActionsAsync(
projectIds,
packageV2.Identity,
VersionConstraints.None,
includePrelease: true,
DependencyBehavior.Lowest,
packageSourceNames,
CancellationToken.None);
Assert.NotEmpty(actions);
Assert.Equal(2, actions.Count);
ProjectAction action = actions[0];
Assert.Equal(packageV1.Identity, action.PackageIdentity);
Assert.Equal(NuGetProjectActionType.Uninstall, action.ProjectActionType);
Assert.Equal(projectId, action.ProjectId);
action = actions[1];
Assert.Equal(packageV2.Identity, action.PackageIdentity);
Assert.Equal(NuGetProjectActionType.Install, action.ProjectActionType);
Assert.Equal(projectId, action.ProjectId);
});
}
}
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_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 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 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 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 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_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());
}
}
