private static async System.Threading.Tasks.Task <Tuple <bool, string> > ContainsReferenceAsync(Project project, string designPackage)
{
var corePackage = "Microsoft.EntityFrameworkCore";
bool hasDesign = false;
string coreVersion = string.Empty;
var projectAssetsFile = await project.GetCspPropertyAsync("ProjectAssetsFile");
if (projectAssetsFile != null && File.Exists(projectAssetsFile))
{
var lockFile = LockFileUtilities.GetLockFile(projectAssetsFile, NuGet.Common.NullLogger.Instance);
if (lockFile != null)
{
foreach (var lib in lockFile.Libraries)
{
if (lib.Name.Equals(corePackage))
{
coreVersion = lib.Version.ToString();
}
if (lib.Name.Equals(designPackage))
{
hasDesign = true;
}
}
}
}
return(new Tuple <bool, string>(hasDesign, coreVersion));
}
public static Tuple <bool, string> ContainsEfCoreDesignReference(this Project project)
{
var designPackage = "Microsoft.EntityFrameworkCore.Design";
var corePackage = "Microsoft.EntityFrameworkCore";
bool hasDesign = false;
string coreVersion = string.Empty;
var projectAssetsFile = project.GetCspProperty("ProjectAssetsFile");
if (projectAssetsFile != null && File.Exists(projectAssetsFile))
{
var lockFile = LockFileUtilities.GetLockFile(projectAssetsFile, NuGet.Common.NullLogger.Instance);
if (lockFile != null)
{
foreach (var lib in lockFile.Libraries)
{
if (lib.Name.Equals(corePackage))
{
coreVersion = lib.Version.ToString();
}
if (lib.Name.Equals(designPackage))
{
hasDesign = true;
}
}
}
}
return(new Tuple <bool, string>(hasDesign, coreVersion));
}
public void It_cleans_without_logging_assets_message()
{
var testAsset = _testAssetsManager
.CopyTestAsset("HelloWorld", "CleanHelloWorld")
.WithSource()
.Restore(Log);
var lockFilePath = Path.Combine(testAsset.TestRoot, "obj", "project.assets.json");
LockFile lockFile = LockFileUtilities.GetLockFile(lockFilePath, NullLogger.Instance);
lockFile.LogMessages.Add(
new AssetsLogMessage(
LogLevel.Warning,
NuGetLogCode.NU1500,
"a test warning",
null));
new LockFileFormat().Write(lockFilePath, lockFile);
var cleanCommand = new CleanCommand(Log, testAsset.TestRoot);
cleanCommand
.Execute("/p:CheckEolTargetFramework=false")
.Should()
.Pass()
.And
.NotHaveStdOutContaining("warning");
}
public IEnumerable <NuGetReference> GetTransitivePackageReferences(TargetFrameworkMoniker tfm)
{
if (PackageReferenceFormat != NugetPackageFormat.PackageReference)
{
return(Enumerable.Empty <NuGetReference>());
}
var parsedTfm = NuGetFramework.Parse(tfm.Name);
var lockFile = LockFileUtilities.GetLockFile(LockFilePath, NuGet.Common.NullLogger.Instance);
if (lockFile is null)
{
throw new ProjectRestoreRequiredException($"Project is not restored: {FileInfo}");
}
var lockFileTarget = lockFile
.Targets
.FirstOrDefault(t => t.TargetFramework.DotNetFrameworkName.Equals(parsedTfm.DotNetFrameworkName, StringComparison.Ordinal));
if (lockFileTarget is null)
{
throw new ProjectRestoreRequiredException($"Could not find {parsedTfm.DotNetFrameworkName} in {LockFilePath} for {FileInfo}");
}
return(lockFileTarget.Libraries.Select(l => new NuGetReference(l.Name, l.Version.ToNormalizedString())));
}
private static async Task <RestoreResultPair> ExecuteAsync(RestoreSummaryRequest summaryRequest, CancellationToken token)
{
var log = summaryRequest.Request.Log;
log.LogVerbose(string.Format(
CultureInfo.CurrentCulture,
Strings.Log_ReadingProject,
summaryRequest.InputPath));
// Run the restore
var request = summaryRequest.Request;
// Read the existing lock file, this is needed to support IsLocked=true
// This is done on the thread and not as part of creating the request due to
// how long it takes to load the lock file.
if (request.ExistingLockFile == null)
{
request.ExistingLockFile = LockFileUtilities.GetLockFile(request.LockFilePath, log);
}
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync(token);
return(new RestoreResultPair(summaryRequest, result));
}
public void The_RuntimeFrameworkVersion_can_float()
{
var testProject = new TestProject()
{
Name = "RuntimeFrameworkVersionFloat",
TargetFrameworks = "netcoreapp2.0",
RuntimeFrameworkVersion = "2.0.*",
IsSdkProject = true,
IsExe = true
};
var testAsset = _testAssetsManager.CreateTestProject(testProject)
.Restore(Log, testProject.Name);
var buildCommand = new BuildCommand(Log, Path.Combine(testAsset.TestRoot, testProject.Name));
buildCommand
.Execute()
.Should()
.Pass();
LockFile lockFile = LockFileUtilities.GetLockFile(Path.Combine(buildCommand.ProjectRootPath, "obj", "project.assets.json"), NullLogger.Instance);
var target = lockFile.GetTarget(NuGetFramework.Parse(testProject.TargetFrameworks), null);
var netCoreAppLibrary = target.Libraries.Single(l => l.Name == "Microsoft.NETCore.App");
// Test that the resolved version is greater than or equal to the latest runtime patch
// we know about, so that when a new runtime patch is released the test doesn't
// immediately start failing
var minimumExpectedVersion = new NuGetVersion(TestContext.LatestRuntimePatchForNetCoreApp2_0);
netCoreAppLibrary.Version.CompareTo(minimumExpectedVersion).Should().BeGreaterOrEqualTo(0,
"the version resolved from a RuntimeFrameworkVersion of '{0}' should be at least {1}",
testProject.RuntimeFrameworkVersion, TestContext.LatestRuntimePatchForNetCoreApp2_0);
}
private void It_targets_the_right_framework(
string testIdentifier,
string targetFramework,
string runtimeFrameworkVersion,
bool selfContained,
bool isExe,
string expectedPackageVersion,
string expectedRuntimeVersion,
string extraMSBuildArguments = null)
{
string runtimeIdentifier = null;
if (selfContained)
{
runtimeIdentifier = EnvironmentInfo.GetCompatibleRid(targetFramework);
}
var testProject = new TestProject()
{
Name = "FrameworkTargetTest",
TargetFrameworks = targetFramework,
RuntimeFrameworkVersion = runtimeFrameworkVersion,
IsSdkProject = true,
IsExe = isExe,
RuntimeIdentifier = runtimeIdentifier
};
var extraArgs = extraMSBuildArguments?.Split(' ') ?? Array.Empty <string>();
var testAsset = _testAssetsManager.CreateTestProject(testProject, testIdentifier)
.Restore(Log, testProject.Name, extraArgs);
var buildCommand = new BuildCommand(Log, Path.Combine(testAsset.TestRoot, testProject.Name));
buildCommand
.Execute(extraArgs)
.Should()
.Pass();
var outputDirectory = buildCommand.GetOutputDirectory(targetFramework, runtimeIdentifier: runtimeIdentifier);
// Self-contained apps don't write a framework version to the runtimeconfig, so only check this for framework-dependent apps
if (isExe && !selfContained)
{
string runtimeConfigFile = Path.Combine(outputDirectory.FullName, testProject.Name + ".runtimeconfig.json");
string runtimeConfigContents = File.ReadAllText(runtimeConfigFile);
JObject runtimeConfig = JObject.Parse(runtimeConfigContents);
string actualRuntimeFrameworkVersion = ((JValue)runtimeConfig["runtimeOptions"]["framework"]["version"]).Value <string>();
actualRuntimeFrameworkVersion.Should().Be(expectedRuntimeVersion);
}
LockFile lockFile = LockFileUtilities.GetLockFile(Path.Combine(buildCommand.ProjectRootPath, "obj", "project.assets.json"), NullLogger.Instance);
var target = lockFile.GetTarget(NuGetFramework.Parse(targetFramework), null);
var netCoreAppLibrary = target.Libraries.Single(l => l.Name == "Microsoft.NETCore.App");
netCoreAppLibrary.Version.ToString().Should().Be(expectedPackageVersion);
}
public async Task DotnetToolTests_ToolRestoreWithFallback_SucceedsAsync()
{
using (var testDirectory = _msbuildFixture.CreateTestDirectory())
{
var actualTfm = "netcoreapp2.0";
var fallbackTfm = "net46";
var projectName = "ToolRestoreProject";
var workingDirectory = Path.Combine(testDirectory, projectName);
var source = Path.Combine(testDirectory, "packageSource");
var rid = "win-x64";
var packageName = string.Join("ToolPackage-", fallbackTfm, rid);
var packageVersion = NuGetVersion.Parse("1.0.0");
var packages = new List <PackageIdentity>()
{
new PackageIdentity(packageName, packageVersion)
};
var package = new SimpleTestPackageContext(packageName, packageVersion.OriginalVersion);
package.Files.Clear();
package.AddFile($"tools/{fallbackTfm}/{rid}/a.dll");
package.AddFile($"tools/{fallbackTfm}/{rid}/Settings.json");
package.PackageType = PackageType.DotnetTool;
package.UseDefaultRuntimeAssemblies = false;
package.PackageTypes.Add(PackageType.DotnetTool);
await SimpleTestPackageUtility.CreatePackagesAsync(source, package);
_msbuildFixture.CreateDotnetToolProject(solutionRoot: testDirectory.Path,
projectName: projectName, targetFramework: actualTfm, rid: rid,
source: source, packages: packages);
using (var stream = File.Open(Path.Combine(workingDirectory, projectName + ".csproj"), FileMode.Open, FileAccess.ReadWrite))
{
var xml = XDocument.Load(stream);
ProjectFileUtils.AddProperty(
xml,
"AssetTargetFallback",
fallbackTfm);
ProjectFileUtils.WriteXmlToFile(xml, stream);
}
// Act
var result = _msbuildFixture.RestoreToolProject(workingDirectory, projectName, string.Empty);
// Assert
Assert.True(result.Item1 == 0, result.AllOutput);
// Verify the assets file
var lockFile = LockFileUtilities.GetLockFile(Path.Combine(testDirectory, projectName, "project.assets.json"), NullLogger.Instance);
Assert.NotNull(lockFile);
Assert.Equal(2, lockFile.Targets.Count);
var ridTargets = lockFile.Targets.Where(e => e.RuntimeIdentifier != null ? e.RuntimeIdentifier.Equals(rid, StringComparison.CurrentCultureIgnoreCase) : false);
Assert.Equal(1, ridTargets.Count());
var toolsAssemblies = ridTargets.First().Libraries.First().ToolsAssemblies;
Assert.Equal(2, toolsAssemblies.Count);
Assert.True(toolsAssemblies.Contains($"tools/{fallbackTfm}/{rid}/a.dll"));
Assert.True(toolsAssemblies.Contains($"tools/{fallbackTfm}/{rid}/Settings.json"));
}
}
public async Task DotnetToolTests_IncompatibleAutorefPackageAndToolsPackageAsync()
{
using (var testDirectory = TestDirectory.Create())
{
var tfm = "netcoreapp1.0";
var incompatibletfm = "netcoreapp2.0";
var rid = "win-x64";
var projectName = "ToolRestoreProject";
var workingDirectory = Path.Combine(testDirectory, projectName);
var localSource = Path.Combine(testDirectory, "packageSource");
var source = "https://api.nuget.org/v3/index.json" + ";" + localSource;
var packageName = string.Join("ToolPackage-", tfm, rid);
var autoReferencePackageName = "Microsoft.NETCore.Platforms";
var packageVersion = NuGetVersion.Parse("1.0.0");
var package = new SimpleTestPackageContext(packageName, packageVersion.OriginalVersion);
package.Files.Clear();
package.AddFile($"tools/{tfm}/{rid}/a.dll");
package.AddFile($"tools/{tfm}/{rid}/Settings.json");
package.PackageType = PackageType.DotnetTool;
package.UseDefaultRuntimeAssemblies = false;
package.PackageTypes.Add(PackageType.DotnetTool);
var autorefPackage = new SimpleTestPackageContext(packageName, packageVersion.OriginalVersion);
autorefPackage.Files.Clear();
autorefPackage.AddFile($"lib/{incompatibletfm}/b.dll");
autorefPackage.UseDefaultRuntimeAssemblies = false;
await SimpleTestPackageUtility.CreatePackagesAsync(localSource, package, autorefPackage);
var packages = new List <PackageIdentity>()
{
new PackageIdentity(packageName, packageVersion),
new PackageIdentity(autoReferencePackageName, packageVersion)
};
_msbuildFixture.CreateDotnetToolProject(solutionRoot: testDirectory.Path,
projectName: projectName, targetFramework: tfm, rid: rid,
source: source, packages: packages);
var fullProjectPath = Path.Combine(workingDirectory, $"{projectName}.csproj");
MakePackageReferenceImplicitlyDefined(fullProjectPath, autoReferencePackageName);
// Act
var result = _msbuildFixture.RestoreToolProject(workingDirectory, projectName, string.Empty);
// Assert
var lockFilePath = Path.Combine(testDirectory, projectName, "project.assets.json");
Assert.True(File.Exists(lockFilePath), result.AllOutput);
var lockFile = LockFileUtilities.GetLockFile(lockFilePath, NullLogger.Instance);
Assert.NotNull(lockFile);
Assert.Equal(2, lockFile.Targets.Count);
var ridTargets = lockFile.Targets.Where(e => e.RuntimeIdentifier != null ? e.RuntimeIdentifier.Equals(rid, StringComparison.CurrentCultureIgnoreCase) : false);
Assert.Equal(1, ridTargets.Count());
Assert.Equal(2, ridTargets.First().Libraries.Count);
Assert.Contains("NU12", result.AllOutput);
}
}
public void It_can_restore_with_netcoreapp2_2()
{
TestProject toolProject = new TestProject()
{
Name = "TestTool" + nameof(It_can_restore_with_netcoreapp2_2),
IsSdkProject = true,
TargetFrameworks = "netcoreapp1.0",
IsExe = true
};
toolProject.AdditionalProperties.Add("PackageType", "DotnetCliTool");
var toolProjectInstance = _testAssetsManager.CreateTestProject(toolProject, identifier: toolProject.Name);
var packCommand = new PackCommand(Log, Path.Combine(toolProjectInstance.TestRoot, toolProject.Name));
packCommand.Execute().Should().Pass();
string nupkgPath = Path.Combine(packCommand.ProjectRootPath, "bin", "Debug");
TestProject toolReferenceProject = new TestProject()
{
Name = "DotNetCliToolReferenceProject",
IsSdkProject = true,
IsExe = true,
TargetFrameworks = "netcoreapp1.0",
};
toolReferenceProject.DotNetCliToolReferences.Add(
new TestPackageReference(id: toolProject.Name,
version: ProjectToolVersion,
nupkgPath: null));
TestAsset toolReferenceProjectInstance = _testAssetsManager.CreateTestProject(toolReferenceProject, identifier: toolReferenceProject.Name);
DeleteFolder(Path.Combine(TestContext.Current.NuGetCachePath, toolProject.Name.ToLowerInvariant()));
DeleteFolder(Path.Combine(TestContext.Current.NuGetCachePath, ".tools", toolProject.Name.ToLowerInvariant()));
NuGetConfigWriter.Write(toolReferenceProjectInstance.TestRoot, NuGetConfigWriter.DotnetCoreBlobFeed, nupkgPath);
RestoreCommand restoreCommand =
toolReferenceProjectInstance.GetRestoreCommand(log: Log, relativePath: toolReferenceProject.Name);
var restoreResult = restoreCommand
.Execute("/v:n");
var assetsJsonPath = Path.Combine(TestContext.Current.NuGetCachePath,
".tools",
toolProject.Name.ToLowerInvariant(),
ProjectToolVersion,
ExpectedProjectToolRestoreTargetFrameworkMoniker,
"project.assets.json");
LockFile lockFile = LockFileUtilities.GetLockFile(assetsJsonPath, NullLogger.Instance);
lockFile.Targets.Single().TargetFramework
.Should().Be(NuGetFramework.Parse(ExpectedProjectToolRestoreTargetFrameworkMoniker),
"Restore target framework should be capped at netcoreapp2.2 due to moving away from project tools." +
"Even when SDK's TFM is higher and the project's TFM is netcoreapp1.0");
}
private static async Task <RestoreSummary> Execute(RestoreSummaryRequest summaryRequest)
{
var log = summaryRequest.Request.Log;
log.LogVerbose(string.Format(
CultureInfo.CurrentCulture,
Strings.Log_ReadingProject,
summaryRequest.InputPath));
// Run the restore
var sw = Stopwatch.StartNew();
var request = summaryRequest.Request;
// Read the existing lock file, this is needed to support IsLocked=true
// This is done on the thread and not as part of creating the request due to
// how long it takes to load the lock file.
if (request.ExistingLockFile == null)
{
request.ExistingLockFile = LockFileUtilities.GetLockFile(request.LockFilePath, log);
}
var command = new RestoreCommand(request);
var result = await command.ExecuteAsync();
// Commit the result
log.LogInformation(Strings.Log_Committing);
await result.CommitAsync(request.Log, CancellationToken.None);
sw.Stop();
if (result.Success)
{
log.LogMinimal(
summaryRequest.InputPath + Environment.NewLine +
string.Format(
CultureInfo.CurrentCulture,
Strings.Log_RestoreComplete,
sw.ElapsedMilliseconds));
}
else
{
log.LogMinimal(
summaryRequest.InputPath + Environment.NewLine +
string.Format(
CultureInfo.CurrentCulture,
Strings.Log_RestoreFailed,
sw.ElapsedMilliseconds));
}
// Build the summary
return(new RestoreSummary(
result,
summaryRequest.InputPath,
summaryRequest.Settings,
summaryRequest.Sources,
summaryRequest.CollectorLogger.Errors));
}
private static IEnumerable <LockFileTargetLibrary> GetAllDependencies(this IProject project)
{
var tfm = NuGetFramework.Parse(project.TFM.Name);
var lockFileTarget = LockFileUtilities.GetLockFile(project.LockFilePath, NuGet.Common.NullLogger.Instance)
.Targets
.First(t => t.TargetFramework.DotNetFrameworkName.Equals(tfm.DotNetFrameworkName, StringComparison.Ordinal));
return(lockFileTarget.Libraries);
}
public void It_targets_the_right_shared_framework(string targetFramework, string runtimeFrameworkVersion, string netCoreAppPackageVersion,
string expectedPackageVersion, string expectedRuntimeVersion)
{
var testProject = new TestProject()
{
Name = "SharedFrameworkTest",
TargetFrameworks = targetFramework,
IsSdkProject = true,
IsExe = true
};
string testIdentifier = string.Join("_", targetFramework, runtimeFrameworkVersion ?? "null", netCoreAppPackageVersion ?? "null");
var testAsset = _testAssetsManager.CreateTestProject(testProject, nameof(It_targets_the_right_shared_framework), testIdentifier);
testAsset = testAsset.WithProjectChanges(project =>
{
var ns = project.Root.Name.Namespace;
var propertyGroup = new XElement(ns + "PropertyGroup");
project.Root.Add(propertyGroup);
if (runtimeFrameworkVersion != null)
{
propertyGroup.Add(new XElement(ns + "RuntimeFrameworkVersion", runtimeFrameworkVersion));
}
if (netCoreAppPackageVersion != null)
{
propertyGroup.Add(new XElement(ns + "NetCoreAppImplicitPackageVersion", netCoreAppPackageVersion));
}
});
testAsset = testAsset.Restore(testProject.Name);
var buildCommand = new BuildCommand(Stage0MSBuild, Path.Combine(testAsset.TestRoot, testProject.Name));
buildCommand
.Execute()
.Should()
.Pass();
var outputDirectory = buildCommand.GetOutputDirectory(targetFramework);
string runtimeConfigFile = Path.Combine(outputDirectory.FullName, testProject.Name + ".runtimeconfig.json");
string runtimeConfigContents = File.ReadAllText(runtimeConfigFile);
JObject runtimeConfig = JObject.Parse(runtimeConfigContents);
string actualRuntimeFrameworkVersion = ((JValue)runtimeConfig["runtimeOptions"]["framework"]["version"]).Value <string>();
actualRuntimeFrameworkVersion.Should().Be(expectedRuntimeVersion);
LockFile lockFile = LockFileUtilities.GetLockFile(Path.Combine(buildCommand.ProjectRootPath, "obj", "project.assets.json"), NullLogger.Instance);
var target = lockFile.GetTarget(NuGetFramework.Parse(targetFramework), null);
var netCoreAppLibrary = target.Libraries.Single(l => l.Name == "Microsoft.NETCore.App");
netCoreAppLibrary.Version.ToString().Should().Be(expectedPackageVersion);
}
private LockFile LoadLockFile(string path)
{
if (!File.Exists(path))
{
throw new ReportUserErrorException($"Assets file '{path}' couldn't be found. Run a NuGet package restore to generate this file.");
}
// TODO - https://github.com/dotnet/sdk/issues/18 adapt task logger to Nuget Logger
return(LockFileUtilities.GetLockFile(path, NullLogger.Instance));
}
private LockFile LoadLockFile(string path)
{
if (!File.Exists(path))
{
throw new BuildErrorException(Strings.AssetsFileNotFound, path);
}
// TODO - https://github.com/dotnet/sdk/issues/18 adapt task logger to Nuget Logger
return(LockFileUtilities.GetLockFile(path, NullLogger.Instance));
}
private LockFile GetLockFile(string projectPath, string outputPath)
{
// Run the restore command
string[] arguments = new[] { "restore", $"\"{projectPath}\"" };
var runStatus = runner.Run(Path.GetDirectoryName(projectPath), arguments);
// Load the lock file
string lockFilePath = Path.Combine(outputPath, "project.assets.json");
return(LockFileUtilities.GetLockFile(lockFilePath, NuGet.Common.NullLogger.Instance));
}
static NuGetVersion GetLibraryVersion(TestProject testProject, BuildCommand buildCommand, string libraryName)
{
LockFile lockFile = LockFileUtilities.GetLockFile(
Path.Combine(buildCommand.GetBaseIntermediateDirectory().FullName, "project.assets.json"),
NullLogger.Instance);
var target = lockFile.GetTarget(NuGetFramework.Parse(testProject.TargetFrameworks), testProject.RuntimeIdentifier);
var lockFileLibrary = target.Libraries.Single(l => l.Name == libraryName);
return(lockFileLibrary.Version);
}
public async Task DotnetToolTests_ToolWithPlatformPackage_SucceedsAsync(string tfm, string packageRid, string projectRid)
{
using (var testDirectory = TestDirectory.Create())
{
var projectName = "ToolRestoreProject";
var workingDirectory = Path.Combine(testDirectory, projectName);
var localSource = Path.Combine(testDirectory, "packageSource");
var packageName = string.Join("ToolPackage-", tfm, packageRid);
var platformsPackageName = "PlatformsPackage";
var packageVersion = NuGetVersion.Parse("1.0.0");
var platformsPackage = new SimpleTestPackageContext(platformsPackageName, packageVersion.OriginalVersion);
platformsPackage.Files.Clear();
platformsPackage.AddFile($"lib/{tfm}/a.dll");
platformsPackage.PackageType = PackageType.Dependency;
platformsPackage.UseDefaultRuntimeAssemblies = true;
platformsPackage.PackageTypes.Add(PackageType.Dependency);
platformsPackage.RuntimeJson = GetResource("Dotnet.Integration.Test.compiler.resources.runtime.json", GetType());
var toolPackage = new SimpleTestPackageContext(packageName, packageVersion.OriginalVersion);
toolPackage.Files.Clear();
toolPackage.AddFile($"tools/{tfm}/{packageRid}/a.dll");
toolPackage.AddFile($"tools/{tfm}/{packageRid}/Settings.json");
toolPackage.PackageType = PackageType.DotnetTool;
toolPackage.UseDefaultRuntimeAssemblies = false;
toolPackage.PackageTypes.Add(PackageType.DotnetTool);
toolPackage.Dependencies.Add(platformsPackage);
await SimpleTestPackageUtility.CreatePackagesAsync(localSource, toolPackage, platformsPackage);
var packages = new List <PackageIdentity>()
{
new PackageIdentity(packageName, packageVersion),
};
_msbuildFixture.CreateDotnetToolProject(solutionRoot: testDirectory.Path,
projectName: projectName, targetFramework: tfm, rid: projectRid,
source: localSource, packages: packages);
// Act
var result = _msbuildFixture.RestoreToolProject(workingDirectory, projectName, string.Empty);
// Assert
Assert.True(result.Item1 == 0, result.AllOutput);
var lockFile = LockFileUtilities.GetLockFile(Path.Combine(testDirectory, projectName, "project.assets.json"), NullLogger.Instance);
Assert.NotNull(lockFile);
Assert.Equal(2, lockFile.Targets.Count);
var ridTargets = lockFile.Targets.Where(e => e.RuntimeIdentifier != null ? e.RuntimeIdentifier.Equals(projectRid, StringComparison.CurrentCultureIgnoreCase) : false);
Assert.Equal(1, ridTargets.Count());
var toolsAssemblies = ridTargets.First().Libraries.First().ToolsAssemblies;
Assert.Equal(2, toolsAssemblies.Count);
Assert.Contains($"tools/{tfm}/{packageRid}", toolsAssemblies.First().Path);
}
}
LockFile LoadLockFile()
{
if (!string.IsNullOrEmpty(ProjectAssetFile) && File.Exists(ProjectAssetFile))
{
LogDebugMessage($"Loading NuGet LockFile: {ProjectAssetFile}");
var logger = new NuGetLogger((s) => {
LogDebugMessage("{0}", s);
});
return(LockFileUtilities.GetLockFile(ProjectAssetFile, logger));
}
return(null);
}
/// <summary>
/// Restore without writing the lock file
/// </summary>
internal static async Task <RestoreResult> RestoreAsync(
BuildIntegratedNuGetProject project,
PackageSpec packageSpec,
ExternalProjectReferenceContext context,
RestoreCommandProviders providers,
CancellationToken token)
{
// Restoring packages
var logger = context.Logger;
logger.LogMinimal(string.Format(CultureInfo.CurrentCulture,
Strings.BuildIntegratedPackageRestoreStarted,
project.ProjectName));
using (var request = new RestoreRequest(packageSpec, providers, logger, disposeProviders: false))
{
request.MaxDegreeOfConcurrency = PackageManagementConstants.DefaultMaxDegreeOfParallelism;
request.LockFileVersion = await GetLockFileVersion(project, context);
// Add the existing lock file if it exists
var lockFilePath = ProjectJsonPathUtilities.GetLockFilePath(project.JsonConfigPath);
request.LockFilePath = lockFilePath;
request.ExistingLockFile = LockFileUtilities.GetLockFile(lockFilePath, logger);
// Find the full closure of project.json files and referenced projects
var projectReferences = await project.GetProjectReferenceClosureAsync(context);
request.ExternalProjects = projectReferences.ToList();
token.ThrowIfCancellationRequested();
var command = new RestoreCommand(request);
// Execute the restore
var result = await command.ExecuteAsync(token);
// Report a final message with the Success result
if (result.Success)
{
logger.LogMinimal(string.Format(CultureInfo.CurrentCulture,
Strings.BuildIntegratedPackageRestoreSucceeded,
project.ProjectName));
}
else
{
logger.LogMinimal(string.Format(CultureInfo.CurrentCulture,
Strings.BuildIntegratedPackageRestoreFailed,
project.ProjectName));
}
return(result);
}
}
public LockFile GetLockFile(string projectPath, string outputPath)
{
string lockFilePath = Path.Combine(outputPath, "project.assets.json");
if (!File.Exists(lockFilePath))
{
// Run the restore command
var dotNetRunner = new ProcessRunner();
string[] arguments = new[] { "restore", $"\"{projectPath}\"" };
var runStatus = dotNetRunner.Run("dotnet", Path.GetDirectoryName(projectPath), arguments);
}
return(LockFileUtilities.GetLockFile(lockFilePath, NuGet.Common.NullLogger.Instance));
}
private LockFile GetLockFile(string pathToAssetsFile)
{
var lockFile = LockFileUtilities.GetLockFile(pathToAssetsFile, _nuGetLogger);
if (lockFile == null)
{
string message = $@"Unable to read lockfile {pathToAssetsFile}.
Make sure that the file exists and that it is a valid 'project.assets.json' file.";
throw new InvalidOperationException(message);
}
return(lockFile);
}
public LockFile GetLockFile(string projectPath, string outputPath)
{
// Run the restore command
var dotNetRunner = new DotNetRunner();
var arguments = new[] { "restore", $"\"{projectPath}\"" };
_ = dotNetRunner.Run(Path.GetDirectoryName(projectPath), arguments);
// Load the lock file
var lockFilePath = Path.Combine(outputPath, "project.assets.json");
return(LockFileUtilities.GetLockFile(lockFilePath, NuGet.Common.NullLogger.Instance));
}
public async Task DotnetToolTests_AutoreferencedDependencyAndToolPackagToolRestore_SucceedsAsync()
{
using (var pathContext = new SimpleTestPathContext())
{
string testDirectory = pathContext.WorkingDirectory;
var tfm = "netcoreapp2.0";
var projectName = "ToolRestoreProject";
var workingDirectory = Path.Combine(testDirectory, projectName);
var packageSource = Path.Combine(testDirectory, "packageSource");
var packageSources = "https://api.nuget.org/v3/index.json" + ";" + packageSource;
var rid = "win-x64";
var packageName = string.Join("ToolPackage-", tfm, rid);
var autoReferencePackageName = "Microsoft.NETCore.Platforms";
var packageVersion = NuGetVersion.Parse("1.0.0");
var package = new SimpleTestPackageContext(packageName, packageVersion.OriginalVersion);
package.Files.Clear();
package.AddFile($"tools/{tfm}/{rid}/a.dll");
package.AddFile($"tools/{tfm}/{rid}/Settings.json");
package.PackageType = PackageType.DotnetTool;
package.UseDefaultRuntimeAssemblies = false;
package.PackageTypes.Add(PackageType.DotnetTool);
await SimpleTestPackageUtility.CreatePackagesAsync(packageSource, package);
var packages = new List <PackageIdentity>()
{
new PackageIdentity(packageName, packageVersion),
new PackageIdentity(autoReferencePackageName, NuGetVersion.Parse("2.0.1"))
};
_msbuildFixture.CreateDotnetToolProject(testDirectory, projectName, tfm, rid, packageSources, packages);
var fullProjectPath = Path.Combine(workingDirectory, $"{projectName}.csproj");
MakePackageReferenceImplicitlyDefined(fullProjectPath, autoReferencePackageName);
// Act
var result = _msbuildFixture.RestoreToolProject(workingDirectory, projectName, string.Empty);
// Assert
var lockFile = LockFileUtilities.GetLockFile(Path.Combine(testDirectory, projectName, "project.assets.json"), NullLogger.Instance);
Assert.NotNull(lockFile);
Assert.Equal(2, lockFile.Targets.Count);
var ridTargets = lockFile.Targets.Where(e => e.RuntimeIdentifier != null ? e.RuntimeIdentifier.Equals(rid, StringComparison.CurrentCultureIgnoreCase) : false);
Assert.Equal(1, ridTargets.Count());
Assert.Equal(2, ridTargets.First().Libraries.Count);
Assert.DoesNotContain("NU12", result.AllOutput); // Output has no errors
Assert.DoesNotContain("NU11", result.AllOutput);
}
}
private KeyValuePair <CacheFile, bool> EvaluateCacheFile()
{
CacheFile cacheFile;
var noOp = false;
var newDgSpecHash = NoOpRestoreUtilities.GetHash(_request);
if (_request.ProjectStyle == ProjectStyle.DotnetCliTool && _request.AllowNoOp)
{
// No need to attempt to resolve the tool if no-op is not allowed.
NoOpRestoreUtilities.UpdateRequestBestMatchingToolPathsIfAvailable(_request);
}
if (_request.AllowNoOp && File.Exists(_request.Project.RestoreMetadata.CacheFilePath))
{
cacheFile = FileUtility.SafeRead(_request.Project.RestoreMetadata.CacheFilePath, (stream, path) => CacheFileFormat.Read(stream, _logger, path));
if (cacheFile.IsValid && StringComparer.Ordinal.Equals(cacheFile.DgSpecHash, newDgSpecHash))
{
_logger.LogVerbose(string.Format(CultureInfo.CurrentCulture, Strings.Log_RestoreNoOpFinish, _request.Project.Name));
_success = true;
noOp = true;
}
else
{
cacheFile = new CacheFile(newDgSpecHash);
_logger.LogVerbose(string.Format(CultureInfo.CurrentCulture, Strings.Log_RestoreNoOpDGChanged, _request.Project.Name));
}
}
else
{
cacheFile = new CacheFile(newDgSpecHash);
}
if (_request.ProjectStyle == ProjectStyle.DotnetCliTool)
{
if (noOp) // Only if the hash matches, then load the lock file. This is a performance hit, so we need to delay it as much as possible.
{
_request.ExistingLockFile = LockFileUtilities.GetLockFile(_request.LockFilePath, _logger);
}
else
{
// Clean up to preserve the pre no-op behavior. This should not be used, but we want to be cautious.
_request.LockFilePath = null;
_request.Project.RestoreMetadata.CacheFilePath = null;
}
}
return(new KeyValuePair <CacheFile, bool>(cacheFile, noOp));
}
public void DotnetToolTests_AutoreferencedDependencyRegularDependencyAndToolPackagToolRestore_Throws(string tfm)
{
using (var testDirectory = TestDirectory.Create())
{
var projectName = "ToolRestoreProject";
var workingDirectory = Path.Combine(testDirectory, projectName);
var localSource = Path.Combine(testDirectory, "packageSource");
var source = "https://api.nuget.org/v3/index.json" + ";" + localSource;
var rid = "win-x64";
var packageName = string.Join("ToolPackage-", tfm, rid);
var autoReferencePackageName = "Microsoft.NETCore.Platforms";
var packageVersion = NuGetVersion.Parse("1.0.0");
var package = new SimpleTestPackageContext(packageName, packageVersion.OriginalVersion);
package.Files.Clear();
package.AddFile($"tools/{tfm}/{rid}/a.dll");
package.AddFile($"tools/{tfm}/{rid}/Settings.json");
package.PackageType = PackageType.DotnetTool;
package.UseDefaultRuntimeAssemblies = false;
package.PackageTypes.Add(PackageType.DotnetTool);
SimpleTestPackageUtility.CreatePackages(localSource, package);
var packages = new List <PackageIdentity>()
{
new PackageIdentity(packageName, packageVersion),
new PackageIdentity(autoReferencePackageName, NuGetVersion.Parse("2.0.1")),
new PackageIdentity("NuGet.Versioning", NuGetVersion.Parse("4.3.0"))
};
_msbuildFixture.CreateDotnetToolProject(solutionRoot: testDirectory.Path,
projectName: projectName, targetFramework: tfm, rid: rid,
source: source, packages: packages);
var fullProjectPath = Path.Combine(workingDirectory, $"{projectName}.csproj");
MakePackageReferenceImplicitlyDefined(fullProjectPath, autoReferencePackageName);
// Act
var result = _msbuildFixture.RestoreToolProject(workingDirectory, projectName, string.Empty);
// Assert
var lockFile = LockFileUtilities.GetLockFile(Path.Combine(testDirectory, projectName, "project.assets.json"), NullLogger.Instance);
Assert.NotNull(lockFile);
Assert.Equal(2, lockFile.Targets.Count);
var ridTargets = lockFile.Targets.Where(e => e.RuntimeIdentifier != null ? e.RuntimeIdentifier.Equals(rid, StringComparison.CurrentCultureIgnoreCase) : false);
Assert.Equal(1, ridTargets.Count());
Assert.Contains("NU12", result.AllOutput); // Output errors because nuget versioning is not autoreferenced
}
}
public LockFile GetLockFile(string projectPath, string outputPath)
{
// Run the restore command
var dotNetRunner = new DotNetRunner();
string[] arguments = new[] { "restore", $"\"{projectPath}\"" };
dotNetRunner.Run(Path.GetDirectoryName(projectPath), arguments);
// TODO: What about packages.lock.json based on package references used as input to download of packages from MyGet
// Load the lock file
string lockFilePath = Path.Combine(outputPath, "project.assets.json");
return(LockFileUtilities.GetLockFile(lockFilePath, NuGet.Common.NullLogger.Instance));
}
public void It_restores_multitargeted_net_framework_project_successfully()
{
var testProject = new TestProject()
{
Name = "ProjectWithoutTargetingPackRef",
TargetFrameworks = "net471;net472;netcoreapp3.0",
IsSdkProject = true,
};
var testAsset = _testAssetsManager.CreateTestProject(testProject);
string projectAssetsJsonPath = Path.Combine(
testAsset.Path,
testProject.Name,
"obj",
"project.assets.json");
var restoreCommand =
testAsset.GetRestoreCommand(Log, relativePath: testProject.Name);
restoreCommand.Execute().Should().Pass();
LockFile lockFile = LockFileUtilities.GetLockFile(
projectAssetsJsonPath,
NullLogger.Instance);
var net471FrameworkLibrary = lockFile.GetTarget(NuGetFramework.Parse(".NETFramework,Version=v4.7.1"), null).Libraries.FirstOrDefault((file) => file.Name.Contains("net471"));
if (TestProject.ReferenceAssembliesAreInstalled(TargetDotNetFrameworkVersion.Version471))
{
net471FrameworkLibrary.Should().BeNull();
}
else
{
net471FrameworkLibrary.Name.Should().Be("Microsoft.NETFramework.ReferenceAssemblies.net471");
net471FrameworkLibrary.Type.Should().Be("package");
}
var net472FrameworkLibrary = lockFile.GetTarget(NuGetFramework.Parse(".NETFramework,Version=v4.7.2"), null).Libraries.FirstOrDefault((file) => file.Name.Contains("net472"));
if (TestProject.ReferenceAssembliesAreInstalled(TargetDotNetFrameworkVersion.Version472))
{
net472FrameworkLibrary.Should().BeNull();
}
else
{
net472FrameworkLibrary.Name.Should().Be("Microsoft.NETFramework.ReferenceAssemblies.net472");
net472FrameworkLibrary.Type.Should().Be("package");
}
}
public void It_restores_net_framework_project_with_existing_references()
{
var targetFramework = "net471";
var testProject = new TestProject()
{
Name = "ProjectWithoutTargetingPackRef",
TargetFrameworks = targetFramework,
IsSdkProject = true,
};
// Add explicit reference to assembly packs
var testAsset = _testAssetsManager.CreateTestProject(testProject).WithProjectChanges(project =>
{
var ns = project.Root.Name.Namespace;
var itemGroup = project.Root.Elements(ns + "ItemGroup").FirstOrDefault();
itemGroup.Add(new XElement(ns + "PackageReference",
new XAttribute("Include", $"Newtonsoft.Json"),
new XAttribute("Version", $"11.0.2")));
itemGroup.Add(new XElement(ns + "PackageReference",
new XAttribute("Include", $"sqlite"),
new XAttribute("Version", $"3.13.0")));
itemGroup.Add(new XElement(ns + "PackageReference",
new XAttribute("Include", $"Microsoft.NETFramework.ReferenceAssemblies"),
new XAttribute("Version", $"1.0.0")));
});
string projectAssetsJsonPath = Path.Combine(
testAsset.Path,
testProject.Name,
"obj",
"project.assets.json");
var restoreCommand =
testAsset.GetRestoreCommand(Log, relativePath: testProject.Name);
restoreCommand.Execute()
.Should()
.Pass()
.And
.NotHaveStdOutContaining("NETSDK1023");
LockFile lockFile = LockFileUtilities.GetLockFile(projectAssetsJsonPath, NullLogger.Instance);
var netFrameworkLibrary = lockFile.GetTarget(NuGetFramework.Parse(".NETFramework,Version=v4.7.1"), null).Libraries.FirstOrDefault((file) => file.Name.Contains(targetFramework));
netFrameworkLibrary.Name.Should().Be("Microsoft.NETFramework.ReferenceAssemblies." + targetFramework);
netFrameworkLibrary.Type.Should().Be("package");
netFrameworkLibrary.Version.ToFullString().Should().Be("1.0.0");
}
public async Task DotnetToolTests_BasicDotnetToolRestoreWithNestedValues_SucceedsAsync()
{
using (var testDirectory = _msbuildFixture.CreateTestDirectory())
{
var tfm = "netcoreapp2.0";
var projectName = "ToolRestoreProject";
var workingDirectory = Path.Combine(testDirectory, projectName);
var source = Path.Combine(testDirectory, "packageSource");
var rid = "win-x64";
var packageName = string.Join("ToolPackage-", tfm, rid);
var packageVersion = NuGetVersion.Parse("1.0.0");
var packages = new List <PackageIdentity>()
{
new PackageIdentity(packageName, packageVersion)
};
var package = new SimpleTestPackageContext(packageName, packageVersion.OriginalVersion);
package.Files.Clear();
package.AddFile($"tools/{tfm}/{rid}/a.dll");
package.AddFile($"tools/{tfm}/{rid}/tool1/b.dll");
package.PackageType = PackageType.DotnetTool;
package.UseDefaultRuntimeAssemblies = false;
package.PackageTypes.Add(PackageType.DotnetTool);
await SimpleTestPackageUtility.CreatePackagesAsync(source, package);
_msbuildFixture.CreateDotnetToolProject(solutionRoot: testDirectory.Path,
projectName: projectName, targetFramework: tfm, rid: rid,
source: source, packages: packages);
// Act
var result = _msbuildFixture.RestoreToolProject(workingDirectory, projectName, string.Empty);
// Assert
Assert.True(result.Item1 == 0, result.AllOutput);
// Verify the assets file
var lockFile = LockFileUtilities.GetLockFile(Path.Combine(testDirectory, projectName, "project.assets.json"), NullLogger.Instance);
Assert.NotNull(lockFile);
Assert.Equal(2, lockFile.Targets.Count);
var ridTargets = lockFile.Targets.Where(e => e.RuntimeIdentifier != null ? e.RuntimeIdentifier.Equals(rid, StringComparison.CurrentCultureIgnoreCase) : false);
Assert.Equal(1, ridTargets.Count());
var toolsAssemblies = ridTargets.First().Libraries.First().ToolsAssemblies;
Assert.Equal(2, toolsAssemblies.Count);
var toolsAssemblyPaths = toolsAssemblies.Select(e => e.Path);
Assert.Contains($"tools/{tfm}/{rid}/a.dll", toolsAssemblyPaths);
Assert.Contains($"tools/{tfm}/{rid}/tool1/b.dll", toolsAssemblyPaths);
}
}