public async Task DotnetCliTool_ToolRestoreNoOpsRegardlessOfProject()
{
// Arrange
using (var pathContext = new SimpleTestPathContext())
{
var logger1 = new TestLogger();
var logger2 = new TestLogger();
var spec1 = ToolRestoreUtility.GetSpec(
Path.Combine(pathContext.SolutionRoot, "fake1.csproj"),
"a",
VersionRange.Parse("1.0.0"),
NuGetFramework.Parse("netcoreapp1.0"),
pathContext.UserPackagesFolder,
new List <string>()
{
pathContext.FallbackFolder
},
new List <PackageSource>()
{
new PackageSource(pathContext.PackageSource)
},
new WarningProperties());
var spec2 = ToolRestoreUtility.GetSpec(
Path.Combine(pathContext.SolutionRoot, "fake2.csproj"),
"a",
VersionRange.Parse("1.0.0"),
NuGetFramework.Parse("netcoreapp1.0"),
pathContext.UserPackagesFolder,
new List <string>()
{
pathContext.FallbackFolder
},
new List <PackageSource>()
{
new PackageSource(pathContext.PackageSource)
},
new WarningProperties());
var dgFile1 = new DependencyGraphSpec();
dgFile1.AddProject(spec1);
dgFile1.AddRestore(spec1.Name);
var dgFile2 = new DependencyGraphSpec();
dgFile2.AddProject(spec2);
dgFile2.AddRestore(spec2.Name);
var pathResolver = new ToolPathResolver(pathContext.UserPackagesFolder);
var path = pathResolver.GetLockFilePath(
"a",
NuGetVersion.Parse("1.0.0"),
NuGetFramework.Parse("netcoreapp1.0"));
await SimpleTestPackageUtility.CreateFolderFeedV3(pathContext.PackageSource, new PackageIdentity("a", NuGetVersion.Parse("1.0.0")));
// Act
var results1 = await CommandsTestUtility.RunRestore(dgFile1, pathContext, logger1);
// Assert
Assert.Equal(1, results1.Count);
var result1 = results1.Single();
Assert.True(result1.Success, "Failed: " + string.Join(Environment.NewLine, logger1.Messages));
Assert.False(result1.NoOpRestore, "Should not no-op: " + string.Join(Environment.NewLine, logger1.Messages));
Assert.True(File.Exists(path));
// Act
var results2 = await CommandsTestUtility.RunRestore(dgFile2, pathContext, logger2);
// Assert
Assert.Equal(1, results2.Count);
var result2 = results2.Single();
Assert.True(result2.Success, "Failed: " + string.Join(Environment.NewLine, logger2.Messages));
Assert.True(result2.NoOpRestore, "Should no-op: " + string.Join(Environment.NewLine, logger2.Messages));
Assert.True(File.Exists(path));
}
}
public async Task DotnetCliTool_VerifyProjectsAreNotAllowed()
{
// Arrange
using (var pathContext = new SimpleTestPathContext())
{
var logger = new TestLogger();
var dgFile = new DependencyGraphSpec();
var spec = ToolRestoreUtility.GetSpec(
Path.Combine(pathContext.SolutionRoot, "tool", "fake.csproj"),
"a",
VersionRange.Parse("1.0.0"),
NuGetFramework.Parse("netcoreapp1.0"),
pathContext.UserPackagesFolder,
new List <string>()
{
pathContext.FallbackFolder
},
new List <PackageSource>()
{
new PackageSource(pathContext.PackageSource)
},
new WarningProperties());
dgFile.AddProject(spec);
dgFile.AddRestore(spec.Name);
var pathResolver = new ToolPathResolver(pathContext.UserPackagesFolder);
var path = pathResolver.GetLockFilePath(
"a",
NuGetVersion.Parse("1.0.0"),
NuGetFramework.Parse("netcoreapp1.0"));
var packageA = new SimpleTestPackageContext()
{
Id = "a",
Version = "1.0.0"
};
var packageB = new SimpleTestPackageContext()
{
Id = "b",
Version = "1.0.0"
};
packageA.Dependencies.Add(packageB);
await SimpleTestPackageUtility.CreateFolderFeedV3(
pathContext.PackageSource,
PackageSaveMode.Defaultv3,
packageA,
packageB);
var projectYRoot = Path.Combine(pathContext.SolutionRoot, "b");
Directory.CreateDirectory(projectYRoot);
var projectYJson = Path.Combine(projectYRoot, "project.json");
var projectJsonContent = JObject.Parse(@"{
'dependencies': {
},
'frameworks': {
'netstandard1.0': {
}
}
}");
File.WriteAllText(projectYJson, projectJsonContent.ToString());
// Act
var result = await CommandsTestUtility.RunSingleRestore(dgFile, pathContext, logger);
// Assert
Assert.True(result.Success, "Failed: " + string.Join(Environment.NewLine, logger.Messages));
Assert.True(File.Exists(path));
var lockFormat = new LockFileFormat();
var lockFile = lockFormat.Read(path);
// Verify only packages
Assert.Empty(lockFile.Libraries.Where(e => e.Type != "package"));
}
}
private static PackageSpec ToToolPackageSpec(ProjectNames projectNames, IVsReferenceItem item, NuGetFramework toolFramework)
{
return(ToolRestoreUtility.GetSpec(projectNames.FullName, item.Name, GetVersionRange(item), toolFramework));
}
public override bool Execute()
{
var log = new MSBuildLogger(Log);
log.LogDebug($"(in) ProjectPath '{ProjectPath}'");
log.LogDebug($"(in) DotnetCliToolReferences '{string.Join(";", DotnetCliToolReferences.Select(p => p.ItemSpec))}'");
if (RestoreSources != null)
{
log.LogDebug($"(in) RestoreSources '{string.Join(";", RestoreSources.Select(p => p))}'");
}
if (RestorePackagesPath != null)
{
log.LogDebug($"(in) RestorePackagesPath '{RestorePackagesPath}'");
}
if (RestoreFallbackFolders != null)
{
log.LogDebug($"(in) RestoreFallbackFolders '{string.Join(";", RestoreFallbackFolders.Select(p => p))}'");
}
if (RestoreConfigFilePaths != null)
{
log.LogDebug($"(in) RestoreConfigFilePaths '{string.Join(";", RestoreConfigFilePaths.Select(p => p))}'");
}
var entries = new List <ITaskItem>();
foreach (var msbuildItem in DotnetCliToolReferences)
{
if (string.IsNullOrEmpty(msbuildItem.ItemSpec))
{
throw new InvalidDataException($"Invalid DotnetCliToolReference in {ProjectPath}");
}
// Create top level project
var properties = new Dictionary <string, string>();
properties.Add("Type", "ProjectSpec");
properties.Add("ProjectPath", ProjectPath);
properties.Add("ProjectName", $"DotnetCliToolReference-{msbuildItem.ItemSpec}");
BuildTasksUtility.AddPropertyIfExists(properties, "Sources", RestoreSources);
BuildTasksUtility.AddPropertyIfExists(properties, "FallbackFolders", RestoreFallbackFolders);
BuildTasksUtility.AddPropertyIfExists(properties, "ConfigFilePaths", RestoreConfigFilePaths);
BuildTasksUtility.AddPropertyIfExists(properties, "PackagesPath", RestorePackagesPath);
properties.Add("TargetFrameworks", ToolFramework);
properties.Add("ProjectStyle", ProjectStyle.DotnetCliTool.ToString());
BuildTasksUtility.CopyPropertyIfExists(msbuildItem, properties, "Version");
properties.TryGetValue("Version", out string value);
var uniqueName = ToolRestoreUtility.GetUniqueName(msbuildItem.ItemSpec, ToolFramework, value != null ? VersionRange.Parse(value) : VersionRange.All);
properties.Add("ProjectUniqueName", uniqueName);
entries.Add(new TaskItem(Guid.NewGuid().ToString(), properties));
// Add reference to package
var packageProperties = new Dictionary <string, string>();
packageProperties.Add("ProjectUniqueName", uniqueName);
packageProperties.Add("Type", "Dependency");
packageProperties.Add("Id", msbuildItem.ItemSpec);
BuildTasksUtility.CopyPropertyIfExists(msbuildItem, packageProperties, "Version", "VersionRange");
packageProperties.Add("TargetFrameworks", ToolFramework);
entries.Add(new TaskItem(Guid.NewGuid().ToString(), packageProperties));
// Add restore spec to ensure this is executed during restore
var restoreProperties = new Dictionary <string, string>();
restoreProperties.Add("ProjectUniqueName", uniqueName);
restoreProperties.Add("Type", "RestoreSpec");
entries.Add(new TaskItem(Guid.NewGuid().ToString(), restoreProperties));
}
RestoreGraphItems = entries.ToArray();
return(true);
}
public void DotnetCliTool_TestGetUniqueName_VersionRangeAll()
{
Assert.Equal("tool-netcoreapp1.0-(, )", ToolRestoreUtility.GetUniqueName("tool", "netcoreapp1.0", VersionRange.All));
}
public void DotnetCliTool_TestGetUniqueName(string name, string framework, string version, string expected)
{
Assert.Equal(expected, ToolRestoreUtility.GetUniqueName(name, framework, VersionRange.Parse(version)));
}
public async Task DotnetCliTool_BasicToolRestore_DifferentVersionRanges()
{
// Arrange
using (var pathContext = new SimpleTestPathContext())
{
var logger = new TestLogger();
var dgFile = new DependencyGraphSpec();
var versions = new List <VersionRange>();
var limit = 100;
for (int i = 0; i < limit; i++)
{
var version = VersionRange.Parse($"{i + 1}.0.0");
versions.Add(version);
var spec = ToolRestoreUtility.GetSpec(
Path.Combine(pathContext.SolutionRoot, $"fake{i}.csproj"),
"a",
version,
NuGetFramework.Parse("netcoreapp1.0"),
pathContext.UserPackagesFolder,
new List <string>()
{
pathContext.FallbackFolder
},
new List <PackageSource>()
{
new PackageSource(pathContext.PackageSource)
},
projectWideWarningProperties: null);
dgFile.AddProject(spec);
dgFile.AddRestore(spec.Name);
}
var pathResolver = new ToolPathResolver(pathContext.UserPackagesFolder);
foreach (var version in versions)
{
await SimpleTestPackageUtility.CreateFolderFeedV3Async(pathContext.PackageSource, new PackageIdentity("a", version.MinVersion));
}
// Act
var results = await CommandsTestUtility.RunRestore(dgFile, pathContext, logger);
// Assert
Assert.Equal(limit, results.Count);
foreach (var result in results)
{
Assert.True(result.Success, "Failed: " + string.Join(Environment.NewLine, logger.Messages));
}
foreach (var version in versions)
{
var path = pathResolver.GetLockFilePath(
"a",
version.MinVersion,
NuGetFramework.Parse("netcoreapp1.0"));
Assert.True(File.Exists(path), $"{path} does not exist!");
}
}
}
