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 ProjectJsonBuildIntegratedNuGetProject(randomConfig, projectFilePath, msBuildNuGetProjectSystem);
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 NuGetProject AddBuildIntegratedProject(string projectName = null, NuGetFramework projectTargetFramework = null)
{
if (GetNuGetProject(projectName) != null)
{
throw new ArgumentException("Project with " + projectName + " already exists");
}
var packagesFolder = Path.Combine(SolutionDirectory, PackagesFolder);
projectName = string.IsNullOrEmpty(projectName) ? Guid.NewGuid().ToString() : projectName;
var projectFullPath = Path.Combine(SolutionDirectory, projectName);
Directory.CreateDirectory(projectFullPath);
var projectJsonPath = Path.Combine(projectFullPath, "project.json");
CreateConfigJson(projectJsonPath);
projectTargetFramework = projectTargetFramework ?? NuGetFramework.Parse("net46");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext(),
projectFullPath, projectName);
var projectFilePath = Path.Combine(projectFullPath, $"{msBuildNuGetProjectSystem.ProjectName}.csproj");
NuGetProject nuGetProject = new ProjectJsonBuildIntegratedNuGetProject(projectJsonPath, projectFilePath);
NuGetProjects.Add(nuGetProject);
return(nuGetProject);
}
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 ProjectJsonBuildIntegratedNuGetProject(randomConfig, projectFilePath, msBuildNuGetProjectSystem);
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);
}
}
void CreateProjectJsonNuGetProject(DotNetProject project)
{
var settings = new FakeNuGetSettings();
var projectJsonFileName = project.BaseDirectory.Combine("project.json");
projectJsonNuGetProject = new ProjectJsonBuildIntegratedNuGetProject(
projectJsonFileName,
project.FileName,
project,
settings);
string json = "{ \"frameworks\": { \".NETPortable,Version=v4.5,Profile=Profile111\": {} }}";
File.WriteAllText(projectJsonFileName, json);
}
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 ProjectJsonBuildIntegratedNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName, msBuildNuGetProjectSystem);
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,
NullSettings.Instance,
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_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 ProjectJsonBuildIntegratedNuGetProject(projectJsonPath, projectFilePath, msBuildNuGetProjectSystem);
var referenceContext = new DependencyGraphCacheContext(new TestLogger());
// 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 BuildIntegratedNuGetProject_IsRestoreRequiredMissingPackage()
{
// 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 ProjectJsonBuildIntegratedNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName, msBuildNuGetProjectSystem);
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,
packagesFolder,
NullSettings.Instance,
testLogger,
CancellationToken.None);
var resolver = new VersionFolderPathResolver(packagesFolder);
var pathToDelete = resolver.GetInstallPath("nuget.versioning", NuGetVersion.Parse("1.0.7"));
TestFileSystemUtility.DeleteRandomTestFolder(pathToDelete);
// Act
var actual = await project.IsRestoreRequired(
new[] { resolver },
new HashSet <PackageIdentity>(),
restoreContext);
// Assert
Assert.True(actual);
}
}
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 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 ProjectJsonBuildIntegratedNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName, msBuildNuGetProjectSystem);
var restoreContext = new DependencyGraphCacheContext(logger);
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,
NullSettings.Instance,
logger,
CancellationToken.None);
var pathContext = NuGetPathContext.Create(NullSettings.Instance);
var oldHash = restoreContext.SolutionSpecHash;
var newContext = new DependencyGraphCacheContext(logger);
// 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(3, 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());
}
}
