public async Task ProjectResolution_HigherVersionForProjectReferences()
{
// Arrange
var project1Json = @"
{
""version"": ""1.0.0-*"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
}
}
}";
var project2Json = @"
{
""version"": ""2.0.0-*"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
}
}
}";
using (var workingDir = TestDirectory.Create())
{
var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource"));
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2"));
packagesDir.Create();
packageSource.Create();
project1.Create();
project2.Create();
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var specPath2 = Path.Combine(project2.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
var spec2 = JsonPackageSpecReader.GetPackageSpec(project2Json, "project2", specPath2);
var logger = new TestLogger();
var restoreContext = new RestoreArgs()
{
Sources = new List <string>()
{
packageSource.FullName
},
GlobalPackagesFolder = packagesDir.FullName,
Log = logger,
CacheContext = new SourceCacheContext()
};
// Modify specs for netcore
spec2 = spec2.WithTestRestoreMetadata();
spec1 = spec1.WithTestRestoreMetadata().WithTestProjectReference(spec2);
var request = await ProjectJsonTestHelpers.GetRequestAsync(restoreContext, spec1, spec2);
request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json");
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
var lockFile = result.LockFile;
await result.CommitAsync(logger, CancellationToken.None);
// Assert
Assert.True(result.Success);
Assert.Equal(0, result.GetAllUnresolved().Count);
Assert.Equal(0, logger.Messages.Where(s => s.IndexOf("Dependency specified was") > -1).Count());
}
}
public async Task MinClientVersion_DependencyVersionTooHighAsync()
{
// Arrange
var sources = new List <PackageSource>();
var project1Json = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""netstandard1.3"": {
""dependencies"": {
""packageA"": ""1.0.0""
}
}
}
}";
using (var workingDir = TestDirectory.Create())
{
var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource"));
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
packagesDir.Create();
packageSource.Create();
project1.Create();
sources.Add(new PackageSource(packageSource.FullName));
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1).EnsureProjectJsonRestoreMetadata();
var logger = new TestLogger();
var request = new TestRestoreRequest(spec1, sources, packagesDir.FullName, logger)
{
LockFilePath = Path.Combine(project1.FullName, "project.lock.json")
};
var packageBContext = new SimpleTestPackageContext()
{
Id = "packageB",
Version = "1.0.0",
MinClientVersion = "9.0.0"
};
var packageAContext = new SimpleTestPackageContext()
{
Id = "packageA",
Version = "1.0.0",
MinClientVersion = "1.0.0",
Dependencies = new List <SimpleTestPackageContext>()
{
packageBContext
}
};
await SimpleTestPackageUtility.CreatePackagesAsync(packageSource.FullName, packageAContext, packageBContext);
Exception ex = null;
// Act
var command = new RestoreCommand(request);
try
{
var result = await command.ExecuteAsync();
}
catch (Exception exception)
{
ex = exception;
}
// Assert
Assert.Contains("The 'packageB 1.0.0' package requires NuGet client version '9.0.0' or above, but the current NuGet version is", ex.Message);
}
}
public async Task RestoreCommand_ObservesLowercaseFlag(bool isLowercase)
{
// Arrange
using (var workingDir = TestDirectory.Create())
{
var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages"));
var sourceDir = new DirectoryInfo(Path.Combine(workingDir, "packageSource"));
var projectDir = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
packagesDir.Create();
sourceDir.Create();
projectDir.Create();
var resolver = new VersionFolderPathResolver(packagesDir.FullName, isLowercase);
var sources = new List<string>();
sources.Add(sourceDir.FullName);
var projectJson = @"
{
""frameworks"": {
""netstandard1.0"": {
""dependencies"": {
""PackageA"": ""1.0.0-Beta""
}
}
}
}";
File.WriteAllText(Path.Combine(projectDir.FullName, "project.json"), projectJson);
var specPath = Path.Combine(projectDir.FullName, "project.json");
var spec = JsonPackageSpecReader.GetPackageSpec(projectJson, "project1", specPath);
var logger = new TestLogger();
var request = new TestRestoreRequest(
spec,
sources.Select(x => Repository.Factory.GetCoreV3(x)),
packagesDir.FullName,
Enumerable.Empty<string>(),
logger)
{
IsLowercasePackagesDirectory = isLowercase
};
request.LockFilePath = Path.Combine(projectDir.FullName, "project.lock.json");
var packageId = "PackageA";
var packageVersion = "1.0.0-Beta";
var packageAContext = new SimpleTestPackageContext(packageId, packageVersion);
packageAContext.AddFile("lib/netstandard1.0/a.dll");
SimpleTestPackageUtility.CreateFullPackage(sourceDir.FullName, packageAContext);
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
var lockFile = result.LockFile;
// Assert
Assert.True(result.Success);
var library = lockFile
.Libraries
.FirstOrDefault(l => l.Name == packageId && l.Version.ToNormalizedString() == packageVersion);
Assert.NotNull(library);
Assert.Equal(
PathUtility.GetPathWithForwardSlashes(resolver.GetPackageDirectory(packageId, library.Version)),
library.Path);
Assert.True(File.Exists(resolver.GetPackageFilePath(packageId, library.Version)));
}
}
public async Task CompatilibityChecker_RuntimeFoundInSamePackage_Success()
{
// Arrange
var sources = new List <PackageSource>();
var project1Json = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""netstandard1.5"": {
""dependencies"": {
""packageA"": {
""version"": ""1.0.0""
}
}
}
}
}";
using (var workingDir = TestFileSystemUtility.CreateRandomTestFolder())
{
var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource"));
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
packagesDir.Create();
packageSource.Create();
project1.Create();
sources.Add(new PackageSource(packageSource.FullName));
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
var logger = new TestLogger();
var request = new RestoreRequest(spec1, sources, packagesDir.FullName, logger);
request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json");
request.RequestedRuntimes.Add("win7-x86");
var packageA = new SimpleTestPackageContext("packageA");
packageA.AddFile("ref/netstandard1.3/a.dll");
packageA.AddFile("ref/netstandard1.3/b.dll");
packageA.AddFile("ref/netstandard1.3/c.dll");
packageA.AddFile("runtimes/win7-x86/lib/netstandard1.1/a.dll");
packageA.AddFile("runtimes/win7-x86/lib/netstandard1.1/b.ni.dll");
packageA.AddFile("runtimes/win7-x86/lib/netstandard1.1/c.dll");
SimpleTestPackageUtility.CreatePackages(packageSource.FullName, packageA);
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
await result.CommitAsync(logger, CancellationToken.None);
// Assert
Assert.True(result.Success, logger.ShowErrors());
// Verify both libraries were installed
Assert.Equal(1, result.LockFile.Libraries.Count);
// Verify no compatibility issues
Assert.True(result.CompatibilityCheckResults.All(check => check.Success));
}
}
public async Task DependencyTypeConstraint_TargetPackage()
{
// Arrange
var sources = new List <PackageSource>();
var project1Json = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""dependencies"": {
""packageA"": {
""version"": ""1.0.0"",
""target"": ""package""
}
},
""frameworks"": {
""net45"": {
}
}
}";
var packageAProjectJson = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
}
}
}";
using (var workingDir = TestDirectory.Create())
{
var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource"));
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
var packageAProject = new DirectoryInfo(Path.Combine(workingDir, "projects", "packageA"));
var packageAExternalProject = new DirectoryInfo(Path.Combine(workingDir, "external", "packageA"));
packagesDir.Create();
packageSource.Create();
project1.Create();
packageAProject.Create();
packageAExternalProject.Create();
sources.Add(new PackageSource(packageSource.FullName));
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
File.WriteAllText(Path.Combine(packageAProject.FullName, "project.json"), packageAProjectJson);
var project1ProjPath = Path.Combine(project1.FullName, "project1.xproj");
File.WriteAllText(project1ProjPath, string.Empty);
File.WriteAllText(Path.Combine(packageAProject.FullName, "packageA.xproj"), string.Empty);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var specPath2 = Path.Combine(packageAProject.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
var spec2 = JsonPackageSpecReader.GetPackageSpec(packageAProjectJson, "packageA", specPath2);
var packageAPath = SimpleTestPackageUtility.CreateFullPackage(
packageSource.FullName,
"packageA",
"1.0.0");
await GlobalFolderUtility.AddPackageToGlobalFolderAsync(packageAPath, packagesDir);
var logger = new TestLogger();
var request = new TestRestoreRequest(spec1, sources, packagesDir.FullName, logger);
request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json");
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
var lockFile = result.LockFile;
await result.CommitAsync(logger, CancellationToken.None);
var packageALib = lockFile.GetLibrary("packageA", NuGetVersion.Parse("1.0.0"));
var packageATarget = lockFile.GetTarget(
FrameworkConstants.CommonFrameworks.Net45,
runtimeIdentifier: null)
.Libraries
.Single(lib => lib.Name == "packageA");
// Assert
Assert.True(result.Success);
Assert.Equal(LibraryType.Package, packageALib.Type);
Assert.Equal(LibraryType.Package, packageATarget.Type);
}
}
public async Task Project2ProjectInLockFile_VerifySnapshotVersionsXProj()
{
// Arrange
var sources = new List <PackageSource>();
var project1Json = @"
{
""version"": ""2.0.0-*"",
""description"": ""Proj1 Class Library"",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""dependencies"": {
""project2"": ""2.0.0-*""
},
""frameworks"": {
""net45"": {
}
}
}";
var project2Json = @"
{
""version"": ""2.0.0-*"",
""description"": ""Proj2 Class Library"",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
}
}
}";
var globalJson = @"
{
""projects"": [
""projects""
]
}";
using (var packagesDir = TestFileSystemUtility.CreateRandomTestFolder())
using (var workingDir = TestFileSystemUtility.CreateRandomTestFolder())
{
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2"));
project1.Create();
project2.Create();
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json);
File.WriteAllText(Path.Combine(workingDir, "global.json"), globalJson);
File.WriteAllText(Path.Combine(project1.FullName, "project1.csproj"), string.Empty);
File.WriteAllText(Path.Combine(project2.FullName, "project2.xproj"), string.Empty);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var specPath2 = Path.Combine(project2.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
var spec2 = JsonPackageSpecReader.GetPackageSpec(project2Json, "project2", specPath2);
var logger = new TestLogger();
var request = new RestoreRequest(spec1, sources, packagesDir, logger);
request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json");
var format = new LockFileFormat();
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
await result.CommitAsync(logger, CancellationToken.None);
var lockFile = format.Read(request.LockFilePath, logger);
var project2Lib = lockFile.GetLibrary("project2", NuGetVersion.Parse("2.0.0"));
var project2Target = lockFile.GetTarget(FrameworkConstants.CommonFrameworks.Net45, runtimeIdentifier: null)
.Libraries
.Single(lib => lib.Name == "project2");
// Assert
Assert.True(result.Success);
Assert.Equal("2.0.0", project2Target.Version.ToString());
Assert.Equal("2.0.0", project2Lib.Version.ToString());
}
}
public async Task CompatilibityChecker_SingleFileVerifyCompatibilityAsync(string file, bool expected)
{
// Arrange
var sources = new List <PackageSource>();
var project1Json = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""netstandard1.5"": {
""dependencies"": {
""packageA"": {
""version"": ""1.0.0""
}
}
}
}
}";
using (var workingDir = TestDirectory.Create())
{
var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource"));
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
packagesDir.Create();
packageSource.Create();
project1.Create();
sources.Add(new PackageSource(packageSource.FullName));
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
var logger = new TestLogger();
var request = new TestRestoreRequest(spec1, sources, packagesDir.FullName, logger)
{
LockFilePath = Path.Combine(project1.FullName, "project.lock.json")
};
request.RequestedRuntimes.Add("win7-x86");
var packageA = new SimpleTestPackageContext("packageA");
packageA.AddFile(file);
// Ensure that the package doesn't pass due to no ref or lib files.
packageA.AddFile("lib/net462/_._");
await SimpleTestPackageUtility.CreatePackagesAsync(packageSource.FullName, packageA);
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
await result.CommitAsync(logger, CancellationToken.None);
// Assert
Assert.Equal(expected, result.Success);
// Verify both libraries were installed
Assert.Equal(1, result.LockFile.Libraries.Count);
// Verify no compatibility issues
Assert.Equal(expected, result.CompatibilityCheckResults.All(check => check.Success));
}
}
public async Task RestoreRunner_RestoreWithRuntime()
{
// Arrange
var sources = new List <PackageSource>();
var project1Json = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
}
}
}";
using (var workingDir = TestDirectory.Create())
{
var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource"));
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
packagesDir.Create();
packageSource.Create();
project1.Create();
sources.Add(new PackageSource(packageSource.FullName));
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
spec1 = spec1.EnsureRestoreMetadata();
spec1.RestoreMetadata.Sources = new List <PackageSource> {
new PackageSource(packageSource.FullName)
};
spec1.RestoreMetadata.PackagesPath = packagesDir.FullName;
var dgSpec = new DependencyGraphSpec();
dgSpec.AddProject(spec1);
dgSpec.AddRestore("project1");
var logger = new TestLogger();
var lockPath1 = Path.Combine(project1.FullName, "project.assets.json");
var sourceRepos = sources.Select(source => Repository.Factory.GetCoreV3(source.Source)).ToList();
var providerCache = new RestoreCommandProvidersCache();
using (var cacheContext = new SourceCacheContext())
{
var restoreContext = new RestoreArgs()
{
CacheContext = cacheContext,
DisableParallel = true,
GlobalPackagesFolder = spec1.RestoreMetadata.PackagesPath,
Sources = new List <string>()
{
packageSource.FullName
},
Log = logger,
CachingSourceProvider = new CachingSourceProvider(new TestPackageSourceProvider(sources)),
PreLoadedRequestProviders = new List <IPreLoadedRestoreRequestProvider>()
{
new DependencyGraphSpecRequestProvider(providerCache, dgSpec)
}
};
restoreContext.Runtimes.Add("linux-x86");
// Act
var summaries = await RestoreRunner.RunAsync(restoreContext);
var success = summaries.All(s => s.Success);
var lockFormat = new LockFileFormat();
var lockFile = lockFormat.Read(lockPath1);
// Assert
Assert.True(success, "Failed: " + string.Join(Environment.NewLine, logger.Messages));
Assert.True(lockFile.Targets.Any(graph => graph.RuntimeIdentifier == "linux-x86"));
}
}
}
public async Task UWPRestore_BlankUWPAppV1()
{
// Arrange
var sources = new List <PackageSource>();
sources.Add(new PackageSource("https://api.nuget.org/v3/index.json"));
using (var packagesDir = TestDirectory.Create())
using (var projectDir = TestDirectory.Create())
{
var configJson = JObject.Parse(@"{
""dependencies"": {
""Microsoft.NETCore.UniversalWindowsPlatform"": ""5.0.0""
},
""frameworks"": {
""uap10.0"": {}
},
""runtimes"": {
""win10-arm"": {},
""win10-arm-aot"": {},
""win10-x86"": {},
""win10-x86-aot"": {},
""win10-x64"": {},
""win10-x64-aot"": {}
}
}");
var specPath = Path.Combine(projectDir, "TestProject", "project.json");
var spec = JsonPackageSpecReader.GetPackageSpec(configJson.ToString(), "TestProject", specPath);
var logger = new TestLogger();
var request = new TestRestoreRequest(spec, sources, packagesDir, logger);
request.LockFilePath = Path.Combine(projectDir, "project.lock.json");
// Set the lock file version to v1 to force a downgrade
request.LockFileVersion = 1;
var lockFileFormat = new LockFileFormat();
var command = new RestoreCommand(request);
var expectedStream = GetResource("NuGet.Commands.FuncTest.compiler.resources.uwpBlankAppV1.json");
JObject expectedJson = null;
using (var reader = new StreamReader(expectedStream))
{
expectedJson = JObject.Parse(reader.ReadToEnd());
}
// Act
var result = await command.ExecuteAsync();
await result.CommitAsync(logger, CancellationToken.None);
var lockFileJson = JObject.Parse(File.ReadAllText(request.LockFilePath));
RemovePackageFolders(lockFileJson);
// Assert
Assert.True(result.Success);
Assert.Equal(0, result.CompatibilityCheckResults.Sum(checkResult => checkResult.Issues.Count));
Assert.Equal(0, logger.Errors);
Assert.Equal(0, logger.Warnings);
Assert.Equal(118, result.GetAllInstalled().Count);
Assert.Equal(expectedJson.ToString(), lockFileJson.ToString());
}
}
public async Task RestoreRunner_BasicRestore()
{
// Arrange
var sources = new List <PackageSource>();
var project1Json = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
}
}
}";
using (var workingDir = TestDirectory.Create())
{
var projectName = "project1";
var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource"));
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", projectName));
packagesDir.Create();
packageSource.Create();
project1.Create();
sources.Add(new PackageSource(packageSource.FullName));
var specPath1 = Path.Combine(project1.FullName, "project.json");
var dgPath = Path.Combine(project1.FullName, "project.dg");
File.WriteAllText(specPath1, project1Json);
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, projectName, specPath1);
spec1 = spec1.EnsureRestoreMetadata();
spec1.RestoreMetadata.Sources = new List <PackageSource> {
new PackageSource(packageSource.FullName)
};
spec1.RestoreMetadata.PackagesPath = packagesDir.FullName;
var dgSpec = new DependencyGraphSpec();
dgSpec.AddProject(spec1);
dgSpec.AddRestore(projectName);
var logger = new TestLogger();
var lockPath = Path.Combine(project1.FullName, "project.assets.json");
var sourceRepos = sources.Select(source => Repository.Factory.GetCoreV3(source.Source)).ToList();
var providerCache = new RestoreCommandProvidersCache();
using (var cacheContext = new SourceCacheContext())
{
var restoreContext = new RestoreArgs()
{
CacheContext = cacheContext,
DisableParallel = true,
GlobalPackagesFolder = packagesDir.FullName,
Sources = new List <string>()
{
packageSource.FullName
},
Log = logger,
CachingSourceProvider = new CachingSourceProvider(new TestPackageSourceProvider(sources)),
PreLoadedRequestProviders = new List <IPreLoadedRestoreRequestProvider>()
{
new DependencyGraphSpecRequestProvider(providerCache, dgSpec)
}
};
// Act
var summaries = await RestoreRunner.RunAsync(restoreContext);
var summary = summaries.Single();
// Assert
Assert.True(summary.Success, "Failed: " + string.Join(Environment.NewLine, logger.Messages));
Assert.Equal(1, summary.FeedsUsed.Count);
Assert.True(File.Exists(lockPath), lockPath);
Assert.False(File.Exists(Path.Combine(project1.FullName, "project1.nuget.targets"))); // TODO NK - Why are we doing this? The name of the targets has changed!
Assert.False(File.Exists(Path.Combine(project1.FullName, "project1.nuget.props")));
}
}
}
public async Task RestoreRunner_BasicRestoreWithConfigFile()
{
// Arrange
var sources = new List <PackageSource>();
var project1Json = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
}
}
}";
var configFile = @"<?xml version=""1.0"" encoding=""utf-8""?>
<configuration>
<packageSources>
<add key=""nuget.org"" value=""{0}"" />
</packageSources>
</configuration>
";
using (var workingDir = TestDirectory.Create())
{
var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource"));
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
packagesDir.Create();
packageSource.Create();
project1.Create();
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
File.WriteAllText(Path.Combine(workingDir, "NuGet.Config"), String.Format(configFile, packageSource.FullName));
var specPath1 = Path.Combine(project1.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
var configPath = Path.Combine(workingDir, "NuGet.Config");
var dgFile = new DependencyGraphSpec();
spec1 = spec1.EnsureRestoreMetadata();
spec1.RestoreMetadata.ConfigFilePaths = new List <string> {
configPath
};
spec1.RestoreMetadata.Sources = new List <PackageSource> {
new PackageSource(packageSource.FullName)
};
spec1.RestoreMetadata.PackagesPath = packagesDir.FullName;
dgFile.AddProject(spec1);
dgFile.AddRestore("project1");
var logger = new TestLogger();
var lockPath = Path.Combine(project1.FullName, "project.assets.json");
var providerCache = new RestoreCommandProvidersCache();
using (var cacheContext = new SourceCacheContext())
{
var restoreContext = new RestoreArgs()
{
CacheContext = cacheContext,
DisableParallel = true,
GlobalPackagesFolder = spec1.RestoreMetadata.PackagesPath,
ConfigFile = configPath,
Log = logger,
CachingSourceProvider = new CachingSourceProvider(new TestPackageSourceProvider(new List <PackageSource>())),
PreLoadedRequestProviders = new List <IPreLoadedRestoreRequestProvider>
{
new DependencyGraphSpecRequestProvider(providerCache, dgFile)
}
};
// Act
var summaries = await RestoreRunner.RunAsync(restoreContext);
var summary = summaries.Single();
// Assert
Assert.True(summary.Success, "Failed: " + string.Join(Environment.NewLine, logger.Messages));
Assert.Equal(1, summary.FeedsUsed.Count);
Assert.True(File.Exists(lockPath), lockPath);
}
}
}
public async Task RestoreRunner_BasicRestore_VerifyFailureWritesFiles_NETCore()
{
// Arrange
var sources = new List <PackageSource>();
var project1Json = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
""dependencies"": {
""x"": ""1.0.0""
}
}
}
}";
using (var workingDir = TestDirectory.Create())
{
var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource"));
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
packagesDir.Create();
packageSource.Create();
project1.Create();
sources.Add(new PackageSource(packageSource.FullName));
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
spec1.RestoreMetadata = new ProjectRestoreMetadata();
spec1.RestoreMetadata.OutputPath = Path.Combine(project1.FullName, "obj");
spec1.RestoreMetadata.ProjectStyle = ProjectStyle.PackageReference;
spec1.RestoreMetadata.ProjectName = "project1";
spec1.RestoreMetadata.ProjectPath = Path.Combine(project1.FullName, "project1.csproj");
spec1.RestoreMetadata.ProjectUniqueName = spec1.RestoreMetadata.ProjectPath;
spec1.RestoreMetadata.TargetFrameworks.Add(new ProjectRestoreMetadataFrameworkInfo(NuGetFramework.Parse("net45")));
spec1.RestoreMetadata.OriginalTargetFrameworks.Add("net45");
spec1.FilePath = spec1.RestoreMetadata.ProjectPath;
var dgSpec = new DependencyGraphSpec();
dgSpec.AddProject(spec1);
dgSpec.AddRestore(spec1.RestoreMetadata.ProjectUniqueName);
var logger = new TestLogger();
var assetsPath = Path.Combine(project1.FullName, "obj", "project.assets.json");
var sourceRepos = sources.Select(source => Repository.Factory.GetCoreV3(source.Source)).ToList();
var providerCache = new RestoreCommandProvidersCache();
using (var cacheContext = new SourceCacheContext())
{
var restoreContext = new RestoreArgs()
{
CacheContext = cacheContext,
DisableParallel = true,
GlobalPackagesFolder = packagesDir.FullName,
Sources = new List <string>()
{
packageSource.FullName
},
Log = logger,
CachingSourceProvider = new CachingSourceProvider(new TestPackageSourceProvider(sources)),
PreLoadedRequestProviders = new List <IPreLoadedRestoreRequestProvider>()
{
new DependencyGraphSpecRequestProvider(providerCache, dgSpec)
}
};
// Act
var summaries = await RestoreRunner.RunAsync(restoreContext);
var summary = summaries.Single();
// Assert
Assert.False(summary.Success);
Assert.True(File.Exists(assetsPath), assetsPath);
Assert.True(File.Exists(Path.Combine(project1.FullName, "obj", "project1.csproj.nuget.g.props")));
Assert.True(File.Exists(Path.Combine(project1.FullName, "obj", "project1.csproj.nuget.g.targets")));
}
}
}
public async Task RestoreRunner_BasicRestore_VerifyFailureWritesFiles()
{
// Arrange
var sources = new List <PackageSource>();
var project1Json = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
""dependencies"": {
""x"": ""1.0.0""
}
}
}
}";
using (var workingDir = TestDirectory.Create())
{
var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource"));
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
packagesDir.Create();
packageSource.Create();
project1.Create();
sources.Add(new PackageSource(packageSource.FullName));
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
spec1 = spec1.EnsureRestoreMetadata();
spec1.RestoreMetadata.Sources = new List <PackageSource> {
new PackageSource(packageSource.FullName)
};
spec1.RestoreMetadata.PackagesPath = packagesDir.FullName;
var dgFile = new DependencyGraphSpec();
dgFile.AddProject(spec1);
dgFile.AddRestore("project1");
var logger = new TestLogger();
var lockPath = Path.Combine(project1.FullName, "project.assets.json");
var sourceRepos = sources.Select(source => Repository.Factory.GetCoreV3(source.Source)).ToList();
var packageX = new SimpleTestPackageContext()
{
Id = "x",
Version = "1.0.0"
};
packageX.AddFile("build/net45/x.targets");
var packageY = new SimpleTestPackageContext("y");
packageX.Dependencies.Add(packageY);
var yPath = SimpleTestPackageUtility.CreateFullPackage(packageSource.FullName, packageY);
SimpleTestPackageUtility.CreateFullPackage(packageSource.FullName, packageX);
// y does not exist
yPath.Delete();
var providerCache = new RestoreCommandProvidersCache();
using (var cacheContext = new SourceCacheContext())
{
var restoreContext = new RestoreArgs()
{
CacheContext = cacheContext,
DisableParallel = true,
GlobalPackagesFolder = packagesDir.FullName,
Sources = new List <string>()
{
packageSource.FullName
},
Log = logger,
CachingSourceProvider = new CachingSourceProvider(new TestPackageSourceProvider(sources)),
PreLoadedRequestProviders = new List <IPreLoadedRestoreRequestProvider>()
{
new DependencyGraphSpecRequestProvider(providerCache, dgFile)
}
};
var targetsPath = Path.Combine(project1.FullName, "project1.csproj.nuget.g.targets");
var propsPath = Path.Combine(project1.FullName, "project1.nuget.props");
// Act
var summaries = await RestoreRunner.RunAsync(restoreContext);
var summary = summaries.Single();
var targets = TargetsUtility.GetMSBuildPackageImports(targetsPath);
// Assert
Assert.False(summary.Success);
Assert.True(File.Exists(lockPath), lockPath);
Assert.True(File.Exists(targetsPath));
Assert.False(File.Exists(propsPath));
Assert.Equal(1, targets.Count);
}
}
}
public async Task ProjectResolution_MSBuildProjectDoesNotResolveByDirectory()
{
// Arrange
var sources = new List <PackageSource>();
var project1Json = @"
{
""version"": ""1.0.0-*"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""dependencies"": {
""project2"": ""1.0.0-*""
},
""frameworks"": {
""net45"": {
}
}
}";
var project2Json = @"
{
""version"": ""1.0.0-*"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
}
}
}";
var globalJson = @"
{
""projects"": [
""projects""
]
}";
using (var workingDir = TestDirectory.Create())
{
var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource"));
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2"));
packagesDir.Create();
packageSource.Create();
project1.Create();
project2.Create();
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json);
File.WriteAllText(Path.Combine(workingDir, "global.json"), globalJson);
var project1CSProjPath = Path.Combine(project1.FullName, "project1.csproj");
File.WriteAllText(project1CSProjPath, string.Empty);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var specPath2 = Path.Combine(project2.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
var spec2 = JsonPackageSpecReader.GetPackageSpec(project2Json, "project2", specPath2);
var logger = new TestLogger();
var request = new TestRestoreRequest(spec1, sources, packagesDir.FullName, logger);
request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json");
request.ExternalProjects.Add(
new ExternalProjectReference("project1", spec1, project1CSProjPath, new string[] { }));
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
var lockFile = result.LockFile;
await result.CommitAsync(logger, CancellationToken.None);
// Assert
Assert.False(result.Success);
Assert.Equal(1, result.GetAllUnresolved().Count);
Assert.Equal("project2", result.GetAllUnresolved().Single().Name);
}
}
public async Task Project2ProjectInLockFile_VerifyProjectsReferencesInLibAndTargets()
{
// Arrange
var sources = new List <PackageSource>();
var project1Json = @"
{
""version"": ""1.0.0"",
""dependencies"": {
""project2"": ""1.0.0-*"",
},
""frameworks"": {
""net45"": {}
}
}";
var project2Json = @"
{
""version"": ""1.0.0"",
""dependencies"": {
""project3"": ""1.0.0-*"",
},
""frameworks"": {
""net45"": {}
}
}";
var project3Json = @"
{
""version"": ""1.0.0"",
""dependencies"": {
},
""frameworks"": {
""net45"": {}
}
}";
var globalJson = @"
{
""projects"": [
""projects""
]
}";
using (var packagesDir = TestFileSystemUtility.CreateRandomTestFolder())
using (var workingDir = TestFileSystemUtility.CreateRandomTestFolder())
{
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2"));
var project3 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project3"));
project1.Create();
project2.Create();
project3.Create();
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json);
File.WriteAllText(Path.Combine(project3.FullName, "project.json"), project3Json);
File.WriteAllText(Path.Combine(workingDir, "global.json"), globalJson);
File.WriteAllText(Path.Combine(project1.FullName, "project1.xproj"), string.Empty);
File.WriteAllText(Path.Combine(project2.FullName, "project2.xproj"), string.Empty);
File.WriteAllText(Path.Combine(project3.FullName, "project3.xproj"), string.Empty);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var spec = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
var specPath2 = Path.Combine(project2.FullName, "project.json");
var specPath3 = Path.Combine(project3.FullName, "project.json");
var logger = new TestLogger();
var request = new RestoreRequest(spec, sources, packagesDir, logger);
request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json");
var format = new LockFileFormat();
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
await result.CommitAsync(logger, CancellationToken.None);
var lockFile = format.Read(request.LockFilePath, logger);
var project1Lib = lockFile.GetLibrary("project1", NuGetVersion.Parse("1.0.0"));
var project2Lib = lockFile.GetLibrary("project2", NuGetVersion.Parse("1.0.0"));
var project3Lib = lockFile.GetLibrary("project3", NuGetVersion.Parse("1.0.0"));
var project2Target = lockFile.GetTarget(FrameworkConstants.CommonFrameworks.Net45, runtimeIdentifier: null)
.Libraries
.Where(lib => lib.Name == "project2")
.Single();
var project3Target = lockFile.GetTarget(FrameworkConstants.CommonFrameworks.Net45, runtimeIdentifier: null)
.Libraries
.Where(lib => lib.Name == "project3")
.Single();
// Assert
Assert.True(result.Success);
Assert.Equal(2, lockFile.Libraries.Count);
Assert.Equal("project", project2Lib.Type);
Assert.Equal("project", project3Lib.Type);
Assert.Equal("../project2/project.json", project2Lib.Path);
Assert.Equal("../project3/project.json", project3Lib.Path);
Assert.Equal("../project2/project2.xproj", project2Lib.MSBuildProject);
Assert.Equal("../project3/project3.xproj", project3Lib.MSBuildProject);
Assert.Equal(1, project2Target.CompileTimeAssemblies.Count);
Assert.Equal("net45/project2.dll", project2Target.CompileTimeAssemblies.Single().Path);
Assert.Equal(1, project3Target.CompileTimeAssemblies.Count);
Assert.Equal("net45/project3.dll", project3Target.CompileTimeAssemblies.Single().Path);
Assert.Equal(1, project2Target.Dependencies.Count);
Assert.Equal("project3", project2Target.Dependencies.Single().Id);
Assert.Equal("1.0.0", project2Target.Dependencies.Single().VersionRange.ToLegacyShortString());
Assert.Equal(0, project3Target.Dependencies.Count);
Assert.Equal(".NETFramework,Version=v4.5", project2Target.Framework);
Assert.Equal(".NETFramework,Version=v4.5", project3Target.Framework);
}
}
private static PackageSpec GetPackageSpecWithProjectNameAndSpec(string projectName, string rootPath, string spec)
{
var packageSpec = JsonPackageSpecReader.GetPackageSpec(spec, projectName, Path.Combine(rootPath, projectName, projectName)).WithTestRestoreMetadata();
return(packageSpec);
}
public async Task Project2ProjectInLockFile_VerifyProjectsNoAddedForV1()
{
// Arrange
var sources = new List <PackageSource>();
var project1Json = @"
{
""version"": ""1.0.0"",
""dependencies"": {
""project2"": ""1.0.0-*"",
},
""frameworks"": {
""net45"": {}
}
}";
var project2Json = @"
{
""version"": ""1.0.0"",
""dependencies"": {
""project3"": ""1.0.0-*"",
},
""frameworks"": {
""net45"": {}
}
}";
var project3Json = @"
{
""version"": ""1.0.0"",
""dependencies"": {
},
""frameworks"": {
""net45"": {}
}
}";
var globalJson = @"
{
""projects"": [
""projects""
]
}";
using (var packagesDir = TestFileSystemUtility.CreateRandomTestFolder())
using (var workingDir = TestFileSystemUtility.CreateRandomTestFolder())
{
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2"));
var project3 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project3"));
project1.Create();
project2.Create();
project3.Create();
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json);
File.WriteAllText(Path.Combine(project3.FullName, "project.json"), project3Json);
File.WriteAllText(Path.Combine(workingDir, "global.json"), globalJson);
File.WriteAllText(Path.Combine(project1.FullName, "project1.xproj"), string.Empty);
File.WriteAllText(Path.Combine(project2.FullName, "project2.xproj"), string.Empty);
File.WriteAllText(Path.Combine(project3.FullName, "project3.xproj"), string.Empty);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var spec = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
var specPath2 = Path.Combine(project2.FullName, "project.json");
var specPath3 = Path.Combine(project3.FullName, "project.json");
var logger = new TestLogger();
var request = new RestoreRequest(spec, sources, packagesDir, logger);
request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json");
request.LockFileVersion = 1;
var format = new LockFileFormat();
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
await result.CommitAsync(logger, CancellationToken.None);
var lockFile = format.Read(request.LockFilePath, logger);
// Assert
Assert.True(result.Success);
Assert.Equal(0, lockFile.Libraries.Count);
Assert.Equal(0, lockFile.Targets[0].Libraries.Count);
// Verify round tripping for v1 with p2ps
Assert.Equal(result.LockFile, lockFile);
}
}
public override async Task <IReadOnlyList <PackageSpec> > GetPackageSpecsAsync(DependencyGraphCacheContext context)
{
PackageSpec packageSpec = null;
if (context == null || !context.PackageSpecCache.TryGetValue(MSBuildProjectPath, out packageSpec))
{
packageSpec = JsonPackageSpecReader.GetPackageSpec(ProjectName, JsonConfigPath);
if (packageSpec == null)
{
throw new InvalidOperationException(
string.Format(Strings.ProjectNotLoaded_RestoreFailed, ProjectName));
}
var metadata = new ProjectRestoreMetadata();
packageSpec.RestoreMetadata = metadata;
metadata.ProjectStyle = ProjectStyle.ProjectJson;
metadata.OutputPath = await GetBaseIntermediatePathAsync();
metadata.ProjectPath = MSBuildProjectPath;
metadata.ProjectJsonPath = packageSpec.FilePath;
metadata.ProjectName = packageSpec.Name;
metadata.ProjectUniqueName = MSBuildProjectPath;
metadata.CacheFilePath = await GetCacheFilePathAsync();
// Reload the target framework from csproj and update the target framework in packageSpec for restore
await UpdateInternalTargetFrameworkAsync();
if (TryGetInternalFramework(out var targetFramework))
{
var nuGetFramework = targetFramework as NuGetFramework;
if (IsUAPFramework(nuGetFramework))
{
// Ensure the project json has only one target framework
if (packageSpec.TargetFrameworks != null && packageSpec.TargetFrameworks.Count == 1)
{
var tfi = packageSpec.TargetFrameworks.First();
if (tfi.Imports.Count > 0)
{
if (tfi.AssetTargetFallback)
{
nuGetFramework = new AssetTargetFallbackFramework(nuGetFramework, tfi.Imports.AsList());
}
else
{
nuGetFramework = new FallbackFramework(nuGetFramework, tfi.Imports.AsList());
}
}
tfi.FrameworkName = nuGetFramework;
}
}
}
var references = (await ProjectServices
.ReferencesReader
.GetProjectReferencesAsync(context.Logger, CancellationToken.None))
.ToList();
if (references != null && references.Count > 0)
{
// Add msbuild reference groups for each TFM in the project
foreach (var framework in packageSpec.TargetFrameworks.Select(e => e.FrameworkName))
{
metadata.TargetFrameworks.Add(new ProjectRestoreMetadataFrameworkInfo(framework));
}
foreach (var reference in references)
{
// This reference applies to all frameworks
// Include/exclude flags may be applied later when merged with project.json
// Add the reference for all TFM groups, there are no conditional project
// references in UWP. There should also be just one TFM.
foreach (var frameworkInfo in metadata.TargetFrameworks)
{
frameworkInfo.ProjectReferences.Add(reference);
}
}
}
// Write restore settings to the package spec.
// For project.json these properties may not come from the project file.
var settings = context?.Settings ?? NullSettings.Instance;
packageSpec.RestoreMetadata.PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings);
packageSpec.RestoreMetadata.Sources = SettingsUtility.GetEnabledSources(settings).AsList();
packageSpec.RestoreMetadata.FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).AsList();
packageSpec.RestoreMetadata.ConfigFilePaths = SettingsUtility.GetConfigFilePaths(settings).AsList();
context?.PackageSpecCache.Add(MSBuildProjectPath, packageSpec);
}
return(new[] { packageSpec });
}
public int Main(string[] args)
{
#if DEBUG
if (args.Contains("--debug"))
{
args = args.Skip(1).ToArray();
System.Diagnostics.Debugger.Launch();
}
#endif
// Set up logging
_log = new CommandOutputLogger();
var app = new CommandLineApplication();
app.Name = "nuget3";
app.FullName = ".NET Package Manager";
app.HelpOption("-h|--help");
app.VersionOption("--version", GetType().GetTypeInfo().Assembly.GetName().Version.ToString());
app.Command("restore", restore =>
{
restore.Description = "Restores packages for a project and writes a lock file";
var sources = restore.Option("-s|--source <source>", "Specifies a NuGet package source to use during the restore", CommandOptionType.MultipleValue);
var packagesDirectory = restore.Option("--packages <packagesDirectory>", "Directory to install packages in", CommandOptionType.SingleValue);
var parallel = restore.Option("-p|--parallel <noneOrNumberOfParallelTasks>", $"The number of concurrent tasks to use when restoring. Defaults to {RestoreRequest.DefaultDegreeOfConcurrency}; pass 'none' to run without concurrency.", CommandOptionType.SingleValue);
var projectFile = restore.Argument("[project file]", "The path to the project to restore for, either a project.json or the directory containing it. Defaults to the current directory");
restore.OnExecute(async() =>
{
// Figure out the project directory
IEnumerable <string> externalProjects = null;
PackageSpec project;
var projectPath = Path.GetFullPath(projectFile.Value ?? ".");
if (string.Equals(PackageSpec.PackageSpecFileName, Path.GetFileName(projectPath), StringComparison.OrdinalIgnoreCase))
{
_log.LogVerbose($"Reading project file {projectFile.Value}");
projectPath = Path.GetDirectoryName(projectPath);
project = JsonPackageSpecReader.GetPackageSpec(File.ReadAllText(projectFile.Value), Path.GetFileName(projectPath), projectFile.Value);
}
else if (MsBuildUtility.IsMsBuildBasedProject(projectPath))
{
#if DNXCORE50
throw new NotSupportedException();
#else
externalProjects = MsBuildUtility.GetProjectReferences(projectPath);
projectPath = Path.GetDirectoryName(Path.GetFullPath(projectPath));
var packageSpecFile = Path.Combine(projectPath, PackageSpec.PackageSpecFileName);
project = JsonPackageSpecReader.GetPackageSpec(File.ReadAllText(packageSpecFile), Path.GetFileName(projectPath), projectFile.Value);
_log.LogVerbose($"Reading project file {projectFile.Value}");
#endif
}
else
{
var file = Path.Combine(projectPath, PackageSpec.PackageSpecFileName);
_log.LogVerbose($"Reading project file {file}");
project = JsonPackageSpecReader.GetPackageSpec(File.ReadAllText(file), Path.GetFileName(projectPath), file);
}
_log.LogVerbose($"Loaded project {project.Name} from {project.FilePath}");
// Resolve the root directory
var rootDirectory = PackageSpecResolver.ResolveRootDirectory(projectPath);
_log.LogVerbose($"Found project root directory: {rootDirectory}");
// Resolve the packages directory
var packagesDir = packagesDirectory.HasValue() ?
packagesDirectory.Value() :
Path.Combine(Environment.GetEnvironmentVariable("USERPROFILE"), ".nuget", "packages");
_log.LogVerbose($"Using packages directory: {packagesDir}");
var packageSources = sources.Values.Select(s => new PackageSource(s));
if (!packageSources.Any())
{
var settings = Settings.LoadDefaultSettings(projectPath,
configFileName: null,
machineWideSettings: null);
var packageSourceProvider = new PackageSourceProvider(settings);
packageSources = packageSourceProvider.LoadPackageSources();
}
var request = new RestoreRequest(
project,
packageSources,
packagesDir);
if (externalProjects != null)
{
foreach (var externalReference in externalProjects)
{
request.ExternalProjects.Add(
new ExternalProjectReference(
externalReference,
Path.Combine(Path.GetDirectoryName(externalReference), PackageSpec.PackageSpecFileName),
projectReferences: Enumerable.Empty <string>()));
}
}
// Run the restore
if (parallel.HasValue())
{
int parallelDegree;
if (string.Equals(parallel.Value(), "none", StringComparison.OrdinalIgnoreCase))
{
request.MaxDegreeOfConcurrency = 1;
}
else if (int.TryParse(parallel.Value(), out parallelDegree))
{
request.MaxDegreeOfConcurrency = parallelDegree;
}
}
if (request.MaxDegreeOfConcurrency <= 1)
{
_log.LogInformation("Running non-parallel restore");
}
else
{
_log.LogInformation($"Running restore with {request.MaxDegreeOfConcurrency} concurrent jobs");
}
var command = new RestoreCommand(_log);
var sw = Stopwatch.StartNew();
var result = await command.ExecuteAsync(request);
sw.Stop();
_log.LogInformation($"Restore completed in {sw.ElapsedMilliseconds:0.00}ms!");
return(0);
});
});
app.Command("diag", diag =>
{
diag.Description = "Diagnostic commands for debugging package dependency graphs";
diag.Command("lockfile", lockfile =>
{
lockfile.Description = "Dumps data from the project lock file";
var project = lockfile.Option("--project <project>", "Path containing the project lockfile, or the patht to the lockfile itself", CommandOptionType.SingleValue);
var target = lockfile.Option("--target <target>", "View information about a specific project target", CommandOptionType.SingleValue);
var library = lockfile.Argument("<library>", "Optionally, get detailed information about a specific library");
lockfile.OnExecute(() =>
{
var diagnostics = new DiagnosticCommands(_log);
var projectFile = project.HasValue() ? project.Value() : Path.GetFullPath(".");
return(diagnostics.Lockfile(projectFile, target.Value(), library.Value));
});
});
diag.OnExecute(() =>
{
diag.ShowHelp();
return(0);
});
});
app.OnExecute(() =>
{
app.ShowHelp();
return(0);
});
return(app.Execute(args));
}
public void DependencyGraphSpec_RoundTripMSBuildMetadata()
{
// Arrange
var frameworks = new List <TargetFrameworkInformation>();
frameworks.Add(new TargetFrameworkInformation()
{
FrameworkName = NuGetFramework.Parse("net45")
});
var spec = new PackageSpec(frameworks);
spec.Version = NuGetVersion.Parse("24.5.1.2-alpha.1.2+a.b.c");
var msbuildMetadata = new ProjectRestoreMetadata();
spec.RestoreMetadata = msbuildMetadata;
msbuildMetadata.ProjectUniqueName = "A55205E7-4D08-4672-8011-0925467CC45F";
msbuildMetadata.ProjectPath = "c:\\x\\x.csproj";
msbuildMetadata.ProjectName = "x";
msbuildMetadata.ProjectJsonPath = "c:\\x\\project.json";
msbuildMetadata.ProjectStyle = ProjectStyle.PackageReference;
msbuildMetadata.PackagesPath = "c:\\packages";
msbuildMetadata.Sources = new[] { new PackageSource("https://api.nuget.org/v3/index.json") };
var tfmGroup = new ProjectRestoreMetadataFrameworkInfo(NuGetFramework.Parse("net45"));
msbuildMetadata.TargetFrameworks.Add(tfmGroup);
tfmGroup.ProjectReferences.Add(new ProjectRestoreReference()
{
ProjectUniqueName = "44B29B8D-8413-42D2-8DF4-72225659619B",
ProjectPath = "c:\\a\\a.csproj"
});
tfmGroup.ProjectReferences.Add(new ProjectRestoreReference()
{
ProjectUniqueName = "78A6AD3F-9FA5-47F6-A54E-84B46A48CB2F",
ProjectPath = "c:\\b\\b.csproj"
});
msbuildMetadata.FallbackFolders.Add("c:\\fallback1");
msbuildMetadata.FallbackFolders.Add("c:\\fallback2");
msbuildMetadata.CrossTargeting = true;
msbuildMetadata.LegacyPackagesDirectory = true;
// Act
var writer = new RuntimeModel.JsonObjectWriter();
PackageSpecWriter.Write(spec, writer);
var json = writer.GetJson();
var readSpec = JsonPackageSpecReader.GetPackageSpec(json, "x", "c:\\fake\\project.json");
var msbuildMetadata2 = readSpec.RestoreMetadata;
// Assert
Assert.NotNull(msbuildMetadata2);
Assert.Equal("A55205E7-4D08-4672-8011-0925467CC45F", msbuildMetadata2.ProjectUniqueName);
Assert.Equal("c:\\x\\x.csproj", msbuildMetadata2.ProjectPath);
Assert.Equal("x", msbuildMetadata2.ProjectName);
Assert.Equal("c:\\x\\project.json", msbuildMetadata2.ProjectJsonPath);
Assert.Equal(ProjectStyle.PackageReference, msbuildMetadata2.ProjectStyle);
Assert.Equal("c:\\packages", msbuildMetadata2.PackagesPath);
Assert.Equal("https://api.nuget.org/v3/index.json", string.Join("|", msbuildMetadata.Sources.Select(s => s.Source)));
Assert.Equal("c:\\fallback1|c:\\fallback2", string.Join("|", msbuildMetadata2.FallbackFolders));
Assert.Equal("44B29B8D-8413-42D2-8DF4-72225659619B|c:\\a\\a.csproj|78A6AD3F-9FA5-47F6-A54E-84B46A48CB2F|c:\\b\\b.csproj", string.Join("|", msbuildMetadata2.TargetFrameworks.Single().ProjectReferences.Select(e => $"{e.ProjectUniqueName}|{e.ProjectPath}")));
Assert.True(msbuildMetadata.CrossTargeting);
Assert.True(msbuildMetadata.LegacyPackagesDirectory);
// Verify build metadata is not lost.
Assert.Equal("24.5.1.2-alpha.1.2+a.b.c", readSpec.Version.ToFullString());
}
public async Task CompatilibityChecker_MissingRuntimeAssembly_FailAsync()
{
// Arrange
var sources = new List <PackageSource>();
var project1Json = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""netstandardapp1.5"": {
""dependencies"": {
""packageA"": {
""version"": ""1.0.0""
}
}
}
}
}";
using (var workingDir = TestDirectory.Create())
{
var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource"));
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
packagesDir.Create();
packageSource.Create();
project1.Create();
sources.Add(new PackageSource(packageSource.FullName));
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
var logger = new TestLogger();
var request = new TestRestoreRequest(spec1, sources, packagesDir.FullName, logger)
{
LockFilePath = Path.Combine(project1.FullName, "project.lock.json")
};
request.RequestedRuntimes.Add("win7-x86");
var packageA = new SimpleTestPackageContext("packageA");
packageA.AddFile("ref/netstandard1.3/a.dll");
await SimpleTestPackageUtility.CreatePackagesAsync(packageSource.FullName, packageA);
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
await result.CommitAsync(logger, CancellationToken.None);
var failure = result.CompatibilityCheckResults.Where(r => !r.Success).Single().Issues.Single();
// Assert
Assert.False(result.Success, logger.ShowErrors());
// Verify both libraries were installed
Assert.Equal(1, result.LockFile.Libraries.Count);
// Verify compatibility issue
Assert.Equal("a", failure.AssemblyName);
Assert.Equal("win7-x86", failure.RuntimeIdentifier);
}
}
public void DependencyGraphSpec_RoundTripMSBuildMetadata_ProjectReferenceFlags()
{
// Arrange
var frameworks = new List <TargetFrameworkInformation>();
frameworks.Add(new TargetFrameworkInformation()
{
FrameworkName = NuGetFramework.Parse("net45")
});
var spec = new PackageSpec(frameworks);
var msbuildMetadata = new ProjectRestoreMetadata();
spec.RestoreMetadata = msbuildMetadata;
msbuildMetadata.ProjectUniqueName = "A55205E7-4D08-4672-8011-0925467CC45F";
msbuildMetadata.ProjectPath = "c:\\x\\x.csproj";
msbuildMetadata.ProjectName = "x";
msbuildMetadata.ProjectStyle = ProjectStyle.PackageReference;
var tfmGroup = new ProjectRestoreMetadataFrameworkInfo(NuGetFramework.Parse("net45"));
var tfmGroup2 = new ProjectRestoreMetadataFrameworkInfo(NuGetFramework.Parse("netstandard1.3"));
msbuildMetadata.TargetFrameworks.Add(tfmGroup);
msbuildMetadata.TargetFrameworks.Add(tfmGroup2);
var ref1 = new ProjectRestoreReference()
{
ProjectUniqueName = "44B29B8D-8413-42D2-8DF4-72225659619B",
ProjectPath = "c:\\a\\a.csproj",
IncludeAssets = LibraryIncludeFlags.Build,
ExcludeAssets = LibraryIncludeFlags.Compile,
PrivateAssets = LibraryIncludeFlags.Runtime
};
var ref2 = new ProjectRestoreReference()
{
ProjectUniqueName = "78A6AD3F-9FA5-47F6-A54E-84B46A48CB2F",
ProjectPath = "c:\\b\\b.csproj"
};
tfmGroup.ProjectReferences.Add(ref1);
tfmGroup.ProjectReferences.Add(ref2);
tfmGroup2.ProjectReferences.Add(ref1);
tfmGroup2.ProjectReferences.Add(ref2);
var writer = new RuntimeModel.JsonObjectWriter();
// Act
PackageSpecWriter.Write(spec, writer);
var json = writer.GetJson();
var readSpec = JsonPackageSpecReader.GetPackageSpec(json, "x", "c:\\fake\\project.json");
// Assert
Assert.Equal(2, readSpec.RestoreMetadata.TargetFrameworks.Count);
foreach (var framework in readSpec.RestoreMetadata.TargetFrameworks)
{
var references = framework.ProjectReferences.OrderBy(e => e.ProjectUniqueName).ToArray();
Assert.Equal("44B29B8D-8413-42D2-8DF4-72225659619B", references[0].ProjectUniqueName);
Assert.Equal(LibraryIncludeFlags.Build, references[0].IncludeAssets);
Assert.Equal(LibraryIncludeFlags.Compile, references[0].ExcludeAssets);
Assert.Equal(LibraryIncludeFlags.Runtime, references[0].PrivateAssets);
Assert.Equal("78A6AD3F-9FA5-47F6-A54E-84B46A48CB2F", references[1].ProjectUniqueName);
Assert.Equal(LibraryIncludeFlags.All, references[1].IncludeAssets);
Assert.Equal(LibraryIncludeFlags.None, references[1].ExcludeAssets);
Assert.Equal(LibraryIncludeFlagUtils.DefaultSuppressParent, references[1].PrivateAssets);
}
}
public async Task CompatilibityChecker_PackageCompatibility_VerifyNoAvailableFrameworks()
{
// Arrange
var sources = new List <PackageSource>();
var project1Json = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""netstandard1.0"": {
""dependencies"": {
""packageA"": {
""version"": ""1.0.0""
}
}
}
}
}";
using (var workingDir = TestFileSystemUtility.CreateRandomTestFolder())
{
var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource"));
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
packagesDir.Create();
packageSource.Create();
project1.Create();
sources.Add(new PackageSource(packageSource.FullName));
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
var logger = new TestLogger();
var request = new RestoreRequest(spec1, sources, packagesDir.FullName, logger);
request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json");
var packageA = new SimpleTestPackageContext("packageA");
packageA.AddFile("ref/a.dll");
SimpleTestPackageUtility.CreatePackages(packageSource.FullName, packageA);
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
await result.CommitAsync(logger, CancellationToken.None);
// Assert
Assert.False(result.Success, logger.ShowErrors());
// Verify both libraries were installed
Assert.Equal(1, result.LockFile.Libraries.Count);
var issue = result.CompatibilityCheckResults.SelectMany(check => check.Issues).Single();
Assert.Equal(@"Package packageA 1.0.0 is not compatible with netstandard1.0 (.NETStandard,Version=v1.0). Package packageA 1.0.0 does not support any target frameworks.".Replace("\n", Environment.NewLine), issue.Format());
}
}
public async Task Project2ProjectInLockFile_VerifyProjectReferenceWithoutVersion()
{
// Arrange
var sources = new List <PackageSource>();
var project1Json = @"
{
""version"": ""2.0.0-*"",
""description"": ""Proj1 Class Library"",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""dependencies"": {
""project2"": { ""target"": ""project"" }
},
""frameworks"": {
""net45"": {
}
}
}";
var project2Json = @"
{
""version"": ""2.0.0-*"",
""description"": ""Proj2 Class Library"",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
}
}
}";
using (var packagesDir = TestFileSystemUtility.CreateRandomTestFolder())
using (var workingDir = TestFileSystemUtility.CreateRandomTestFolder())
{
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2"));
project1.Create();
project2.Create();
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var specPath2 = Path.Combine(project2.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
var spec2 = JsonPackageSpecReader.GetPackageSpec(project2Json, "project2", specPath2);
var logger = new TestLogger();
var request = new RestoreRequest(spec1, sources, packagesDir, logger);
request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json");
var format = new LockFileFormat();
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
await result.CommitAsync(logger, CancellationToken.None);
var lockFile = format.Read(request.LockFilePath, logger);
var project2Reference = lockFile.ProjectFileDependencyGroups.First().Dependencies.Single();
// Assert
Assert.True(result.Success);
Assert.Equal("project2", project2Reference);
}
}
public async Task DependencyTypeConstraint_PackagesDependOnProject()
{
// Arrange
var sources = new List <PackageSource>();
var project1Json = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""dependencies"": {
""packageA"": ""1.0.0""
},
""frameworks"": {
""net45"": {
}
}
}";
var packageBProjectJson = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
}
}
}";
using (var workingDir = TestDirectory.Create())
{
var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource"));
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
var packageBProject = new DirectoryInfo(Path.Combine(workingDir, "projects", "packageB"));
packagesDir.Create();
packageSource.Create();
project1.Create();
packageBProject.Create();
sources.Add(new PackageSource(packageSource.FullName));
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
File.WriteAllText(Path.Combine(packageBProject.FullName, "project.json"), packageBProjectJson);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var specPath2 = Path.Combine(packageBProject.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
var spec2 = JsonPackageSpecReader.GetPackageSpec(packageBProjectJson, "packageB", specPath2);
var packageAPath = SimpleTestPackageUtility.CreateFullPackage(
packageSource.FullName,
"packageA",
"1.0.0",
new Packaging.Core.PackageDependency[]
{
new Packaging.Core.PackageDependency("packageB", VersionRange.Parse("1.0.0"))
});
await GlobalFolderUtility.AddPackageToGlobalFolderAsync(packageAPath, packagesDir);
var logger = new TestLogger();
var restoreContext = new RestoreArgs()
{
Sources = new List <string>()
{
packageSource.FullName
},
GlobalPackagesFolder = packagesDir.FullName,
Log = logger,
CacheContext = new SourceCacheContext()
};
// Modify specs for netcore
spec2 = spec2.WithTestRestoreMetadata();
spec1 = spec1.WithTestRestoreMetadata().WithTestProjectReference(spec2);
var request = await ProjectJsonTestHelpers.GetRequestAsync(restoreContext, spec1, spec2);
request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json");
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
var lockFile = result.LockFile;
await result.CommitAsync(logger, CancellationToken.None);
// Assert
Assert.True(result.Success);
var packageBLib = lockFile.GetLibrary("packageB", NuGetVersion.Parse("1.0.0"));
Assert.NotNull(packageBLib);
Assert.Equal(LibraryType.Project, packageBLib.Type);
}
}
public async Task Project2ProjectInLockFile_PackageReferenceConflict()
{
// Arrange
var sources = new List <PackageSource>()
{
new PackageSource("https://api.nuget.org/v3/index.json")
};
var project1Json = @"
{
""version"": ""1.0.0"",
""dependencies"": {
},
""frameworks"": {
""net45"": {}
}
}";
var project2Json = @"
{
""version"": ""1.0.0"",
""dependencies"": {
""Microsoft.VisualBasic"": ""10.0.0""
},
""frameworks"": {
""net45"": {}
}
}";
using (var packagesDir = TestFileSystemUtility.CreateRandomTestFolder())
using (var workingDir = TestFileSystemUtility.CreateRandomTestFolder())
{
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2"));
project1.Create();
project2.Create();
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json);
File.WriteAllText(Path.Combine(project1.FullName, "project1.csproj"), string.Empty);
File.WriteAllText(Path.Combine(project2.FullName, "project2.csproj"), string.Empty);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var specPath2 = Path.Combine(project2.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
var spec2 = JsonPackageSpecReader.GetPackageSpec(project2Json, "project2", specPath2);
var logger = new TestLogger();
var request = new RestoreRequest(spec1, sources, packagesDir, logger);
request.ExternalProjects.Add(new ExternalProjectReference(
"project1",
spec1,
Path.Combine(project1.FullName, "project1.csproj"),
new string[] { "project2" }));
request.ExternalProjects.Add(new ExternalProjectReference(
"project2",
spec2,
Path.Combine(project2.FullName, "project2.csproj"),
new string[] { }));
request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json");
var format = new LockFileFormat();
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
await result.CommitAsync(logger, CancellationToken.None);
// Assert
Assert.True(result.Success, logger.ShowMessages());
}
}
public async Task RestoreCommand_PackageAndReferenceWithSameNameAndVersion()
{
// Arrange
var sources = new List<PackageSource>();
// Both TxMs reference packageA, but they are different types.
// Verify that the reference does not show up under libraries.
var project1Json = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
""frameworkAssemblies"": {
""packageA"": ""4.0.0""
}
},
""netstandard1.3"": {
""dependencies"": {
""packageA"": ""4.0.0""
}
}
}
}";
using (var workingDir = TestDirectory.Create())
{
var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource"));
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
packagesDir.Create();
packageSource.Create();
project1.Create();
sources.Add(new PackageSource(packageSource.FullName));
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
var logger = new TestLogger();
var request = new TestRestoreRequest(spec1, sources, packagesDir.FullName, logger);
request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json");
SimpleTestPackageUtility.CreateFullPackage(packageSource.FullName, "packageA", "4.0.0");
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
var lockFile = result.LockFile;
await result.CommitAsync(logger, CancellationToken.None);
// Assert
Assert.True(result.Success);
Assert.Equal(1, lockFile.Libraries.Count);
}
}
public async Task Project2ProjectInLockFile_CSProjToXProj()
{
// Arrange
var sources = new List <PackageSource>();
var projectJson = @"
{
""version"": ""1.0.0"",
""dependencies"": {
},
""frameworks"": {
""net45"": {}
}
}";
var project2Json = @"
{
""version"": ""1.0.0-*"",
""description"": ""Proj2 Class Library"",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
}
}
}";
using (var packagesDir = TestFileSystemUtility.CreateRandomTestFolder())
using (var workingDir = TestFileSystemUtility.CreateRandomTestFolder())
{
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2"));
project1.Create();
project2.Create();
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), projectJson);
File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json);
File.WriteAllText(Path.Combine(project1.FullName, "project1.csproj"), string.Empty);
File.WriteAllText(Path.Combine(project2.FullName, "project2.xproj"), string.Empty);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var specPath2 = Path.Combine(project2.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(projectJson, "project1", specPath1);
var spec2 = JsonPackageSpecReader.GetPackageSpec(project2Json, "project2", specPath2);
var logger = new TestLogger();
var request = new RestoreRequest(spec1, sources, packagesDir, logger);
request.ExternalProjects.Add(new ExternalProjectReference(
"project1",
spec1,
Path.Combine(project1.FullName, "project1.xproj"),
new string[] { "project2" }));
request.ExternalProjects.Add(new ExternalProjectReference(
"project2",
spec2,
Path.Combine(project2.FullName, "project2.xproj"),
new string[] { }));
request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json");
var format = new LockFileFormat();
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
await result.CommitAsync(logger, CancellationToken.None);
var lockFile = format.Read(request.LockFilePath, logger);
var project2Lib = lockFile.GetLibrary("project2", NuGetVersion.Parse("1.0.0"));
var project2Target = lockFile.GetTarget(FrameworkConstants.CommonFrameworks.Net45, runtimeIdentifier: null)
.Libraries
.Where(lib => lib.Name == "project2")
.Single();
// Assert
Assert.True(result.Success);
Assert.Equal(1, lockFile.Libraries.Count);
Assert.Equal("project", project2Lib.Type);
Assert.Equal("../project2/project.json", project2Lib.Path);
Assert.Equal("../project2/project2.xproj", project2Lib.MSBuildProject);
Assert.Equal(".NETFramework,Version=v4.5", project2Target.Framework);
Assert.Equal(1, project2Target.CompileTimeAssemblies.Count);
Assert.Equal("net45/project2.dll", project2Target.CompileTimeAssemblies.Single().Path);
}
}
public async Task RestoreCommand_VerifyRuntimeSpecificAssetsAreNotIncludedForCompile_RuntimeOnly()
{
// Arrange
var sources = new List<PackageSource>();
var project1Json = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""netstandard1.5"": {
""dependencies"": {
""packageA"": ""1.0.0""
}
}
},
""runtimes"": {
""win7-x64"": {}
}
}";
using (var workingDir = TestDirectory.Create())
{
var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource"));
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
packagesDir.Create();
packageSource.Create();
project1.Create();
sources.Add(new PackageSource(packageSource.FullName));
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
var logger = new TestLogger();
var request = new TestRestoreRequest(spec1, sources, packagesDir.FullName, logger);
request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json");
var packageAContext = new SimpleTestPackageContext("packageA");
packageAContext.AddFile("runtimes/win7-x64/lib/netstandard1.5/a.dll");
SimpleTestPackageUtility.CreateFullPackage(packageSource.FullName, packageAContext);
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
var lockFile = result.LockFile;
await result.CommitAsync(logger, CancellationToken.None);
var targetLib = lockFile.GetTarget(NuGetFramework.Parse("netstandard1.5"), "win7-x64")
.Libraries
.Single(library => library.Name == "packageA");
// Assert
Assert.True(result.Success);
Assert.Equal(0, targetLib.CompileTimeAssemblies.Count);
Assert.Equal("runtimes/win7-x64/lib/netstandard1.5/a.dll", targetLib.RuntimeAssemblies.Single());
}
}
public async Task ProjectResolution_ExternalReferenceWithNoProjectJson()
{
// Arrange
var sources = new List <PackageSource>();
var project1Json = @"
{
""version"": ""1.0.0-*"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
}
}
}";
using (var workingDir = TestDirectory.Create())
{
var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource"));
var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1"));
var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2"));
packagesDir.Create();
packageSource.Create();
project1.Create();
project2.Create();
File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json);
var msbuidPath1 = Path.Combine(project2.FullName, "project1.xproj");
var msbuidPath2 = Path.Combine(project2.FullName, "project2.csproj");
File.WriteAllText(msbuidPath1, string.Empty);
File.WriteAllText(msbuidPath2, string.Empty);
var specPath1 = Path.Combine(project1.FullName, "project.json");
var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1);
var logger = new TestLogger();
var request = new TestRestoreRequest(spec1, sources, packagesDir.FullName, logger);
request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json");
request.ExternalProjects.Add(new ExternalProjectReference(
"project1",
spec1,
msbuidPath1,
new string[] { "project2" }));
request.ExternalProjects.Add(new ExternalProjectReference(
"project2",
null,
msbuidPath2,
new string[] { }));
// Act
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
var lockFile = result.LockFile;
await result.CommitAsync(logger, CancellationToken.None);
var targetLib = lockFile.Targets.Single().Libraries.Single();
// Assert
Assert.True(result.Success);
// External projects that did not provide a framework should leave the framework property out
Assert.Null(targetLib.Framework);
}
}
