public void PackagesLockFileFormat_Write()
{
var nuGetLockFileContent = @"{
""version"": 1,
""dependencies"": {
"".NETFramework,Version=v4.5"": {
""PackageA"": {
""type"": ""Direct"",
""requested"": ""[1.*, )"",
""resolved"": ""1.0.0"",
""sha512"": ""sbWWhjA2/cXJHBBKAVo3m2U0KxzNuW5dQANDwx8L96V+L6SML96cM/Myvmp6fiBqIDibvF6+Ss9YC+qqclrXnw=="",
""dependencies"": {
""PackageB"": ""1.0.0""
}
},
""PackageB"": {
""type"": ""Transitive"",
""resolved"": ""1.0.0"",
""sha512"": ""Fjiywrwerewr4dgbdgbfgjkoiuiorwrwn24+8hjnnuerwrwsfsHYWD3HJYUI7NJHssxDFSFSFEWEW34DFDFCVsxv=="",
}
}
}
}";
var lockFile = PackagesLockFileFormat.Parse(nuGetLockFileContent, "In Memory");
var output = JObject.Parse(PackagesLockFileFormat.Render(lockFile));
var expected = JObject.Parse(nuGetLockFileContent);
// Assert
Assert.Equal(expected.ToString(), output.ToString());
}
public async Task InstallingPackageShouldCreateLockFile_CustomLockFileName()
{
// Arrange
using (var packageSource = TestDirectory.Create())
using (var testSolutionManager = new TestSolutionManager())
{
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(
new List <PackageSource>()
{
new PackageSource(packageSource.Path)
});
var testSettings = NullSettings.Instance;
var token = CancellationToken.None;
var deleteOnRestartManager = new TestDeleteOnRestartManager();
var nuGetPackageManager = new NuGetPackageManager(
sourceRepositoryProvider,
testSettings,
testSolutionManager,
deleteOnRestartManager);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var packageContext = new SimpleTestPackageContext("packageA");
packageContext.AddFile("lib/net45/a.dll");
SimpleTestPackageUtility.CreateOPCPackage(packageContext, packageSource);
var msBuildNuGetProject = testSolutionManager.AddNewMSBuildProject();
var msBuildNuGetProjectSystem = msBuildNuGetProject.ProjectSystem as TestMSBuildNuGetProjectSystem;
msBuildNuGetProjectSystem.SetPropertyValue("RestorePackagesWithLockFile", "true");
msBuildNuGetProjectSystem.SetPropertyValue("NuGetLockFilePath", "my.lock.json");
var packagesConfigPath = msBuildNuGetProject.PackagesConfigNuGetProject.FullPath;
var packagesLockPath = packagesConfigPath.Replace("packages.config", "my.lock.json");
var packageIdentity = packageContext.Identity;
// Pre-Assert
// Check that the packages.lock.json file does not exist
Assert.False(File.Exists(packagesLockPath));
// Act
await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, packageIdentity,
new ResolutionContext(), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
// Check that the packages.lock.json file exists after the installation
Assert.True(File.Exists(packagesLockPath));
Assert.True(msBuildNuGetProjectSystem.FileExistsInProject("my.lock.json"));
// Check the number of target frameworks and dependencies in the lock file
var lockFile = PackagesLockFileFormat.Read(packagesLockPath);
Assert.Equal(1, lockFile.Targets.Count);
Assert.Equal(1, lockFile.Targets[0].Dependencies.Count);
}
}
public async Task Restore_LegacyPackageReference_WithNuGetLockFile()
{
// Arrange
using (var pathContext = new SimpleTestPathContext())
{
// Set up solution, project, and packages
var solution = new SimpleTestSolutionContext(pathContext.SolutionRoot);
var net461 = NuGetFramework.Parse("net461");
var projectA = SimpleTestProjectContext.CreateLegacyPackageReference(
"a",
pathContext.SolutionRoot,
net461);
projectA.Properties.Add("RestorePackagesWithLockFile", "true");
var packageX = new SimpleTestPackageContext()
{
Id = "x",
Version = "1.0.0"
};
packageX.Files.Clear();
packageX.AddFile("lib/net461/a.dll");
projectA.AddPackageToAllFrameworks(packageX);
solution.Projects.Add(projectA);
solution.Create(pathContext.SolutionRoot);
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
pathContext.PackageSource,
PackageSaveMode.Defaultv3,
packageX);
// Act
var result = RunRestore(pathContext);
// Assert
Assert.True(File.Exists(projectA.NuGetLockFileOutputPath));
var lockFile = PackagesLockFileFormat.Read(projectA.NuGetLockFileOutputPath);
Assert.Equal(4, lockFile.Targets.Count);
var targets = lockFile.Targets.Where(t => t.Dependencies.Count > 0).ToList();
Assert.Equal(1, targets.Count);
Assert.Equal(".NETFramework,Version=v4.6.1", targets[0].Name);
Assert.Equal(1, targets[0].Dependencies.Count);
Assert.Equal("x", targets[0].Dependencies[0].Id);
}
}
private async Task CommitLockFileAsync(ILogger log, bool toolCommit)
{
// write packages lock file if it's not tool commit
if (!toolCommit && _newPackagesLockFile != null && !string.IsNullOrEmpty(_newPackagesLockFilePath))
{
log.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Log_WritingPackagesLockFile,
_newPackagesLockFilePath));
await FileUtility.ReplaceWithLock(
(outputPath) => PackagesLockFileFormat.Write(outputPath, _newPackagesLockFile),
_newPackagesLockFilePath);
}
}
public void PackagesLockFileFormat_Read()
{
var nuGetLockFileContent = @"{
""version"": 1,
""dependencies"": {
"".NETFramework,Version=v4.5"": {
""PackageA"": {
""type"": ""Direct"",
""requested"": ""[1.*, )"",
""resolved"": ""1.0.0"",
""sha512"": ""sbWWhjA2/cXJHBBKAVo3m2U0KxzNuW5dQANDwx8L96V+L6SML96cM/Myvmp6fiBqIDibvF6+Ss9YC+qqclrXnw=="",
""dependencies"": {
""PackageB"": ""1.0.0""
}
},
""PackageB"": {
""type"": ""Transitive"",
""resolved"": ""1.0.0"",
""sha512"": ""Fjiywrwerewr4dgbdgbfgjkoiuiorwrwn24+8hjnnuerwrwsfsHYWD3HJYUI7NJHssxDFSFSFEWEW34DFDFCVsxv=="",
}
}
}
}";
var lockFile = PackagesLockFileFormat.Parse(nuGetLockFileContent, "In Memory");
Assert.Equal(1, lockFile.Targets.Count);
var target = lockFile.Targets.First();
Assert.Equal(".NETFramework,Version=v4.5", target.Name);
Assert.Equal(2, target.Dependencies.Count);
Assert.Equal("PackageA", target.Dependencies[0].Id);
Assert.Equal(PackageDependencyType.Direct, target.Dependencies[0].Type);
Assert.Equal("[1.*, )", target.Dependencies[0].RequestedVersion.ToNormalizedString());
Assert.Equal("1.0.0", target.Dependencies[0].ResolvedVersion.ToNormalizedString());
Assert.NotEmpty(target.Dependencies[0].Sha512);
Assert.Equal(1, target.Dependencies[0].Dependencies.Count);
Assert.Equal("PackageB", target.Dependencies[0].Dependencies[0].Id);
Assert.Equal("PackageB", target.Dependencies[1].Id);
Assert.Equal(PackageDependencyType.Transitive, target.Dependencies[1].Type);
Assert.Null(target.Dependencies[1].RequestedVersion);
Assert.Equal("1.0.0", target.Dependencies[0].ResolvedVersion.ToNormalizedString());
Assert.NotEmpty(target.Dependencies[1].Sha512);
}
internal static void UpdateLockFile(
MSBuildNuGetProject msbuildProject,
List <NuGetProjectAction> actionsList,
CancellationToken token)
{
if (msbuildProject == null)
{
// probably a `nuget.exe install` command, which doesn't support lock files until lock file arguments are implemented
return;
}
var lockFileName = GetPackagesLockFilePath(msbuildProject);
var lockFileExists = File.Exists(lockFileName);
var enableLockFile = IsRestorePackagesWithLockFileEnabled(msbuildProject);
if (enableLockFile == false && lockFileExists)
{
var message = string.Format(CultureInfo.CurrentCulture, Strings.Error_InvalidLockFileInput, lockFileName);
throw new InvalidOperationException(message);
}
else if (enableLockFile == true || lockFileExists)
{
var lockFile = GetLockFile(lockFileExists, lockFileName);
lockFile.Targets[0].TargetFramework = msbuildProject.ProjectSystem.TargetFramework;
var contentHashUtil = new PackagesConfigContentHashProvider(msbuildProject.FolderNuGetProject);
ApplyChanges(lockFile, actionsList, contentHashUtil, token);
PackagesLockFileFormat.Write(lockFileName, lockFile);
// Add lock file to msbuild project, so it appears in solution explorer and is added to TFS source control.
if (msbuildProject != null)
{
var projectUri = new Uri(msbuildProject.MSBuildProjectPath);
var lockFileUri = new Uri(lockFileName);
var lockFileRelativePath = projectUri.MakeRelativeUri(lockFileUri).OriginalString;
if (Path.DirectorySeparatorChar != '/')
{
lockFileRelativePath.Replace('/', Path.DirectorySeparatorChar);
}
msbuildProject.ProjectSystem.AddExistingFile(lockFileRelativePath);
}
}
}
internal static PackagesLockFile GetLockFile(bool lockFileExists, string lockFileName)
{
PackagesLockFile lockFile;
if (lockFileExists)
{
lockFile = PackagesLockFileFormat.Read(lockFileName);
lockFile.Version = PackagesLockFileFormat.Version;
if (lockFile.Targets.Count == 0)
{
lockFile.Targets.Add(new PackagesLockFileTarget());
}
else if (lockFile.Targets.Count > 1)
{
// merge lists
while (lockFile.Targets.Count > 1)
{
var target = lockFile.Targets[1];
for (var i = 0; i < target.Dependencies.Count; i++)
{
lockFile.Targets[0].Dependencies.Add(target.Dependencies[i]);
}
lockFile.Targets.RemoveAt(1);
}
}
}
else
{
lockFile = new PackagesLockFile();
lockFile.Targets.Add(new PackagesLockFileTarget());
}
return(lockFile);
}
public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_UpdateLockFile()
{
using (var packageSource = TestDirectory.Create())
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(
new List <Configuration.PackageSource>()
{
new Configuration.PackageSource(packageSource.Path)
});
using (var testSolutionManager = new TestSolutionManager(true))
using (var randomProjectFolderPath = TestDirectory.Create())
{
var testSettings = PopulateSettingsWithSources(sourceRepositoryProvider, randomProjectFolderPath);
var testNuGetProjectContext = new TestNuGetProjectContext();
var deleteOnRestartManager = new TestDeleteOnRestartManager();
var nuGetPackageManager = new NuGetPackageManager(
sourceRepositoryProvider,
testSettings,
testSolutionManager,
deleteOnRestartManager);
var projectTargetFrameworkStr = "net45";
var fullProjectPath = Path.Combine(randomProjectFolderPath, "project1.csproj");
var projectLockFilePath = Path.Combine(randomProjectFolderPath, "packages.custom.lock.json");
File.Create(projectLockFilePath).Close();
var projectNames = new ProjectNames(
fullName: fullProjectPath,
uniqueName: Path.GetFileName(fullProjectPath),
shortName: Path.GetFileNameWithoutExtension(fullProjectPath),
customUniqueName: Path.GetFileName(fullProjectPath));
var vsProjectAdapter = new TestVSProjectAdapter(
fullProjectPath,
projectNames,
projectTargetFrameworkStr,
restorePackagesWithLockFile: null,
nuGetLockFilePath: projectLockFilePath);
var projectServices = new TestProjectSystemServices();
projectServices.SetupInstalledPackages(
NuGetFramework.Parse(projectTargetFrameworkStr),
new LibraryDependency
{
LibraryRange = new LibraryRange(
"packageA",
VersionRange.Parse("1.*"),
LibraryDependencyTarget.Package)
});
var legacyPRProject = new LegacyPackageReferenceProject(
vsProjectAdapter,
Guid.NewGuid().ToString(),
projectServices,
_threadingService);
testSolutionManager.NuGetProjects.Add(legacyPRProject);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger, testSettings);
var packageContextA = new SimpleTestPackageContext("packageA", "1.0.0");
packageContextA.AddFile("lib/net45/a.dll");
SimpleTestPackageUtility.CreateOPCPackage(packageContextA, packageSource);
var packageContextB = new SimpleTestPackageContext("packageB", "1.0.0");
packageContextB.AddFile("lib/net45/b.dll");
SimpleTestPackageUtility.CreateOPCPackage(packageContextB, packageSource);
var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(testSolutionManager, restoreContext);
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
testSolutionManager,
dgSpec,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sourceRepositoryProvider.GetRepositories(),
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
foreach (var restoreSummary in restoreSummaries)
{
Assert.True(restoreSummary.Success);
Assert.False(restoreSummary.NoOpRestore);
}
Assert.True(File.Exists(projectLockFilePath));
Assert.True(File.Exists(Path.Combine(vsProjectAdapter.MSBuildProjectExtensionsPath, "project.assets.json")));
// delete existing restore output files
File.Delete(Path.Combine(vsProjectAdapter.MSBuildProjectExtensionsPath, "project.assets.json"));
// install a new package
projectServices.SetupInstalledPackages(
NuGetFramework.Parse(projectTargetFrameworkStr),
new LibraryDependency
{
LibraryRange = new LibraryRange(
"packageA",
VersionRange.Parse("1.*"),
LibraryDependencyTarget.Package)
},
new LibraryDependency
{
LibraryRange = new LibraryRange(
"packageB",
VersionRange.Parse("1.0.0"),
LibraryDependencyTarget.Package)
});
// update the proeject with new ProjectService instance
restoreContext.PackageSpecCache.Clear();
dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(testSolutionManager, restoreContext);
// Act
restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
testSolutionManager,
dgSpec,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sourceRepositoryProvider.GetRepositories(),
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
// Assert
foreach (var restoreSummary in restoreSummaries)
{
Assert.True(restoreSummary.Success);
Assert.False(restoreSummary.NoOpRestore);
}
Assert.True(File.Exists(projectLockFilePath));
var lockFile = PackagesLockFileFormat.Read(projectLockFilePath);
Assert.Equal(2, lockFile.Targets.First().Dependencies.Count);
}
}
}
public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_GenerateLockFile()
{
using (var packageSource = TestDirectory.Create())
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(
new List <Configuration.PackageSource>()
{
new Configuration.PackageSource(packageSource.Path)
});
using (var testSolutionManager = new TestSolutionManager(true))
using (var randomProjectFolderPath = TestDirectory.Create())
{
var testSettings = PopulateSettingsWithSources(sourceRepositoryProvider, randomProjectFolderPath);
var testNuGetProjectContext = new TestNuGetProjectContext();
var deleteOnRestartManager = new TestDeleteOnRestartManager();
var nuGetPackageManager = new NuGetPackageManager(
sourceRepositoryProvider,
testSettings,
testSolutionManager,
deleteOnRestartManager);
// set up projects
var projectTargetFrameworkStr = "net45";
var fullProjectPathB = Path.Combine(randomProjectFolderPath, "ProjectB", "project2.csproj");
var projectNamesB = new ProjectNames(
fullName: fullProjectPathB,
uniqueName: Path.GetFileName(fullProjectPathB),
shortName: Path.GetFileNameWithoutExtension(fullProjectPathB),
customUniqueName: Path.GetFileName(fullProjectPathB));
var vsProjectAdapterB = new TestVSProjectAdapter(
fullProjectPathB,
projectNamesB,
projectTargetFrameworkStr);
var projectServicesB = new TestProjectSystemServices();
projectServicesB.SetupInstalledPackages(
NuGetFramework.Parse(projectTargetFrameworkStr),
new LibraryDependency
{
LibraryRange = new LibraryRange(
"packageB",
VersionRange.Parse("1.*"),
LibraryDependencyTarget.Package)
});
var legacyPRProjectB = new LegacyPackageReferenceProject(
vsProjectAdapterB,
Guid.NewGuid().ToString(),
projectServicesB,
_threadingService);
var projectPathA = Path.Combine(randomProjectFolderPath, "ProjectA");
var fullProjectPathA = Path.Combine(projectPathA, "project1.csproj");
var projectNamesA = new ProjectNames(
fullName: fullProjectPathA,
uniqueName: Path.GetFileName(fullProjectPathA),
shortName: Path.GetFileNameWithoutExtension(fullProjectPathA),
customUniqueName: Path.GetFileName(fullProjectPathA));
var vsProjectAdapterA = new TestVSProjectAdapter(
fullProjectPathA,
projectNamesA,
projectTargetFrameworkStr,
restorePackagesWithLockFile: "true");
var projectServicesA = new TestProjectSystemServices();
projectServicesA.SetupInstalledPackages(
NuGetFramework.Parse(projectTargetFrameworkStr),
new LibraryDependency
{
LibraryRange = new LibraryRange(
"packageA",
VersionRange.Parse("1.*"),
LibraryDependencyTarget.Package)
});
projectServicesA.SetupProjectDependencies(
new ProjectRestoreReference
{
ProjectUniqueName = fullProjectPathB,
ProjectPath = fullProjectPathB
});
var legacyPRProjectA = new LegacyPackageReferenceProject(
vsProjectAdapterA,
Guid.NewGuid().ToString(),
projectServicesA,
_threadingService);
testSolutionManager.NuGetProjects.Add(legacyPRProjectB);
testSolutionManager.NuGetProjects.Add(legacyPRProjectA);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger, testSettings);
var providersCache = new RestoreCommandProvidersCache();
var packageContextA = new SimpleTestPackageContext("packageA", "1.0.0");
packageContextA.AddFile("lib/net45/a.dll");
var packageContextB = new SimpleTestPackageContext("packageB", "1.0.0");
packageContextB.AddFile("lib/net45/b.dll");
var packages = new List <SimpleTestPackageContext>()
{
packageContextA, packageContextB
};
SimpleTestPackageUtility.CreateOPCPackages(packages, packageSource);
var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(testSolutionManager, restoreContext);
// Act
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
testSolutionManager,
dgSpec,
restoreContext,
providersCache,
(c) => { },
sourceRepositoryProvider.GetRepositories(),
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
// Assert
foreach (var restoreSummary in restoreSummaries)
{
Assert.True(restoreSummary.Success);
Assert.False(restoreSummary.NoOpRestore);
}
Assert.True(File.Exists(Path.Combine(projectPathA, "packages.lock.json")));
var lockFile = PackagesLockFileFormat.Read(Path.Combine(projectPathA, "packages.lock.json"));
Assert.Equal(1, lockFile.Targets.Count);
Assert.Equal(".NETFramework,Version=v4.5", lockFile.Targets[0].Name);
Assert.Equal(3, lockFile.Targets[0].Dependencies.Count);
Assert.Equal("packageA", lockFile.Targets[0].Dependencies[0].Id);
Assert.Equal(PackageDependencyType.Direct, lockFile.Targets[0].Dependencies[0].Type);
Assert.Equal("packageB", lockFile.Targets[0].Dependencies[1].Id);
Assert.Equal(PackageDependencyType.Transitive, lockFile.Targets[0].Dependencies[1].Type);
Assert.Equal("project2", lockFile.Targets[0].Dependencies[2].Id);
Assert.Equal(PackageDependencyType.Project, lockFile.Targets[0].Dependencies[2].Type);
}
}
}
public async Task Restore_LegacyPackageReference_WithNuGetLockFilePath()
{
// Arrange
using (var pathContext = new SimpleTestPathContext())
{
// Set up solution, project, and packages
var solution = new SimpleTestSolutionContext(pathContext.SolutionRoot);
var net461 = "net461";
var projectA = SimpleTestProjectContext.CreateLegacyPackageReference(
"a",
pathContext.SolutionRoot,
NuGetFramework.Parse(net461));
var projectB = SimpleTestProjectContext.CreateLegacyPackageReference(
"b",
pathContext.SolutionRoot,
NuGetFramework.Parse(net461));
// set up packages
var packageX = new SimpleTestPackageContext()
{
Id = "x",
Version = "1.0.0"
};
packageX.Files.Clear();
packageX.AddFile($"lib/{0}/x.dll", net461);
var packageY = new SimpleTestPackageContext()
{
Id = "y",
Version = "1.0.0"
};
packageY.Files.Clear();
packageY.AddFile($"lib/{0}/y.dll", net461);
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
pathContext.PackageSource,
PackageSaveMode.Defaultv3,
packageX,
packageY);
// set up projects and solution
projectB.AddPackageToAllFrameworks(packageY);
projectA.Properties.Add("RestorePackagesWithLockFile", "true");
var packagesLockFilePath = Path.Combine(Path.GetDirectoryName(projectA.ProjectPath), "packages.custom.lock.json");
projectA.Properties.Add("NuGetLockFilePath", packagesLockFilePath);
projectA.AddProjectToAllFrameworks(projectB);
projectA.AddPackageToAllFrameworks(packageX);
solution.Projects.Add(projectA);
solution.Projects.Add(projectB);
solution.Create(pathContext.SolutionRoot);
// Act
var result = RunRestore(pathContext);
// Assert
Assert.True(File.Exists(projectA.NuGetLockFileOutputPath));
Assert.Equal(packagesLockFilePath, projectA.NuGetLockFileOutputPath);
var lockFile = PackagesLockFileFormat.Read(projectA.NuGetLockFileOutputPath);
Assert.Equal(4, lockFile.Targets.Count);
var targets = lockFile.Targets.Where(t => t.Dependencies.Count > 0).ToList();
Assert.Equal(1, targets.Count);
Assert.Equal(".NETFramework,Version=v4.6.1", targets[0].Name);
Assert.Equal(3, targets[0].Dependencies.Count);
Assert.Equal("x", targets[0].Dependencies[0].Id);
Assert.Equal(PackageDependencyType.Direct, targets[0].Dependencies[0].Type);
Assert.Equal("y", targets[0].Dependencies[1].Id);
Assert.Equal(PackageDependencyType.Transitive, targets[0].Dependencies[1].Type);
Assert.Equal("b", targets[0].Dependencies[2].Id);
Assert.Equal(PackageDependencyType.Project, targets[0].Dependencies[2].Type);
}
}
public void PackagesLockFileFormat_ReadWithRuntimeGraph()
{
var nuGetLockFileContent = @"{
""version"": 1,
""dependencies"": {
"".NETFramework,Version=v4.5"": {
""PackageA"": {
""type"": ""Direct"",
""requested"": ""[1.*, )"",
""resolved"": ""1.0.0"",
""sha512"": ""sbWWhjA2/cXJHBBKAVo3m2U0KxzNuW5dQANDwx8L96V+L6SML96cM/Myvmp6fiBqIDibvF6+Ss9YC+qqclrXnw=="",
""dependencies"": {
""PackageB"": ""1.0.0""
}
},
""PackageB"": {
""type"": ""Transitive"",
""resolved"": ""1.0.0"",
""sha512"": ""Fjiywrwerewr4dgbdgbfgjkoiuiorwrwn24+8hjnnuerwrwsfsHYWD3HJYUI7NJHssxDFSFSFEWEW34DFDFCVsxv==""
}
},
"".NETFramework,Version=v4.5/win10-arm"": {
""PackageA"": {
""type"": ""Direct"",
""requested"": ""[1.*, )"",
""resolved"": ""1.0.0"",
""sha512"": ""QuiokjhjA2/cXJHBBKAVo3m2U0KxzNuW5dQANDwx8L96V+L6SML96cM/Myvmp6fiBqIDibvF6+Ss9YC+qqcfwef=="",
""dependencies"": {
""PackageB"": ""1.0.0"",
""runtime.win10-arm.PackageA"": ""1.0.0""
}
},
""runtime.win10-arm.PackageA"": {
""type"": ""Transitive"",
""resolved"": ""1.0.0"",
""sha512"": ""dfgdgdfIY434jhjkhkRARFSZSGFSDG423452bgdnuerwrwsfsHYWD3HJYUI7NJHssxDFSFSFEWEW34DFjkyuerd=="",
}
}
}
}";
var lockFile = PackagesLockFileFormat.Parse(nuGetLockFileContent, "In Memory");
Assert.Equal(2, lockFile.Targets.Count);
var target = lockFile.Targets.First(t => !string.IsNullOrEmpty(t.RuntimeIdentifier));
Assert.Equal(".NETFramework,Version=v4.5/win10-arm", target.Name);
Assert.Equal(2, target.Dependencies.Count);
Assert.Equal("PackageA", target.Dependencies[0].Id);
Assert.Equal(PackageDependencyType.Direct, target.Dependencies[0].Type);
Assert.Equal("[1.*, )", target.Dependencies[0].RequestedVersion.ToNormalizedString());
Assert.Equal("1.0.0", target.Dependencies[0].ResolvedVersion.ToNormalizedString());
Assert.NotEmpty(target.Dependencies[0].Sha512);
Assert.Equal(2, target.Dependencies[0].Dependencies.Count);
Assert.Equal("PackageB", target.Dependencies[0].Dependencies[0].Id);
Assert.Equal("runtime.win10-arm.PackageA", target.Dependencies[0].Dependencies[1].Id);
// Runtime graph will only have additional transitive dependenies which are not part of
// original TFM graph
Assert.Equal("runtime.win10-arm.PackageA", target.Dependencies[1].Id);
Assert.Equal(PackageDependencyType.Transitive, target.Dependencies[1].Type);
Assert.Null(target.Dependencies[1].RequestedVersion);
Assert.Equal("1.0.0", target.Dependencies[0].ResolvedVersion.ToNormalizedString());
Assert.NotEmpty(target.Dependencies[1].Sha512);
}
public void Read_VariousTargetFrameworksAndRuntimeIdentifiers_ParsedCorrectly()
{
// Arrange
var lockFileContents =
@"{
""version"": 1,
""dependencies"": {
"".NETFramework,Version=v4.7.2"": { },
"".NETStandard,Version=v2.0"": { },
"".NETCoreApp,Version=3.1"": { },
"".NETCoreApp,Version=3.1/win-x64"": { },
"".NETCoreApp,Version=5.0"": { },
"".NETCoreApp,Version=5.0/win-x64"": { },
""net5.0-windows7.0"": { },
""net5.0-windows7.0/win-x64"": { },
""net6.0"": { },
""net6.0/win-x64"": { },
""net6.0-windows7.0"": { },
""net6.0-windows7.0/win-x64"": { },
}
}";
// Act
var lockFile = PackagesLockFileFormat.Parse(lockFileContents, "In memory");
// Assert
Assert.Equal(12, lockFile.Targets.Count);
Assert.Equal(FrameworkConstants.CommonFrameworks.Net472, lockFile.Targets[0].TargetFramework);
Assert.Null(lockFile.Targets[0].RuntimeIdentifier);
Assert.Equal(FrameworkConstants.CommonFrameworks.NetStandard20, lockFile.Targets[1].TargetFramework);
Assert.Null(lockFile.Targets[1].RuntimeIdentifier);
Assert.Equal(FrameworkConstants.CommonFrameworks.NetCoreApp31, lockFile.Targets[2].TargetFramework);
Assert.Null(lockFile.Targets[2].RuntimeIdentifier);
Assert.Equal(FrameworkConstants.CommonFrameworks.NetCoreApp31, lockFile.Targets[3].TargetFramework);
Assert.Equal("win-x64", lockFile.Targets[3].RuntimeIdentifier);
Assert.Equal(FrameworkConstants.CommonFrameworks.Net50, lockFile.Targets[4].TargetFramework);
Assert.Null(lockFile.Targets[4].RuntimeIdentifier);
Assert.Equal(FrameworkConstants.CommonFrameworks.Net50, lockFile.Targets[5].TargetFramework);
Assert.Equal("win-x64", lockFile.Targets[5].RuntimeIdentifier);
NuGetFramework net5win7 = NuGetFramework.Parse("net5.0-windows7.0");
Assert.Equal(net5win7, lockFile.Targets[6].TargetFramework);
Assert.Null(lockFile.Targets[6].RuntimeIdentifier);
Assert.Equal(net5win7, lockFile.Targets[7].TargetFramework);
Assert.Equal("win-x64", lockFile.Targets[7].RuntimeIdentifier);
Assert.Equal(FrameworkConstants.CommonFrameworks.Net60, lockFile.Targets[8].TargetFramework);
Assert.Null(lockFile.Targets[8].RuntimeIdentifier);
Assert.Equal(FrameworkConstants.CommonFrameworks.Net60, lockFile.Targets[9].TargetFramework);
Assert.Equal("win-x64", lockFile.Targets[9].RuntimeIdentifier);
NuGetFramework net6win7 = NuGetFramework.Parse("net6.0-windows7.0");
Assert.Equal(net6win7, lockFile.Targets[10].TargetFramework);
Assert.Null(lockFile.Targets[10].RuntimeIdentifier);
Assert.Equal(net6win7, lockFile.Targets[11].TargetFramework);
Assert.Equal("win-x64", lockFile.Targets[11].RuntimeIdentifier);
}
public static IReadOnlyList <IRestoreLogMessage> ValidatePackagesConfigLockFiles(
string projectFile,
string packagesConfigFile,
string projectName,
string nuGetLockFilePath,
string restorePackagesWithLockFile,
NuGetFramework projectTfm,
string packagesFolderPath,
bool restoreLockedMode,
CancellationToken token)
{
var lockFilePath = GetPackagesLockFilePath(Path.GetDirectoryName(packagesConfigFile), nuGetLockFilePath, projectName);
var lockFileExists = File.Exists(lockFilePath);
var lockFileOptIn = MSBuildStringUtility.GetBooleanOrNull(restorePackagesWithLockFile);
var useLockFile = lockFileOptIn == true || lockFileExists;
if (lockFileOptIn == false && lockFileExists)
{
var message = string.Format(CultureInfo.CurrentCulture, Strings.Error_InvalidLockFileInput, lockFilePath);
var errors = new List <IRestoreLogMessage>();
var log = RestoreLogMessage.CreateError(NuGetLogCode.NU1005, message, packagesConfigFile);
log.ProjectPath = projectFile ?? packagesConfigFile;
errors.Add(log);
return(errors);
}
if (useLockFile)
{
PackagesLockFile projectLockFileEquivalent = PackagesConfigLockFileUtility.FromPackagesConfigFile(packagesConfigFile,
projectTfm,
packagesFolderPath,
token);
if (!lockFileExists)
{
PackagesLockFileFormat.Write(lockFilePath, projectLockFileEquivalent);
return(null);
}
else
{
PackagesLockFile lockFile = PackagesLockFileFormat.Read(lockFilePath);
PackagesLockFileUtilities.LockFileValidityWithMatchedResults comparisonResult = PackagesLockFileUtilities.IsLockFileStillValid(projectLockFileEquivalent, lockFile);
if (comparisonResult.IsValid)
{
// check sha hashes
bool allContentHashesMatch = comparisonResult.MatchedDependencies.All(pair => pair.Key.ContentHash == pair.Value.ContentHash);
if (allContentHashesMatch)
{
return(null);
}
else
{
var errors = new List <IRestoreLogMessage>();
foreach (var difference in comparisonResult.MatchedDependencies.Where(kvp => kvp.Key.ContentHash != kvp.Value.ContentHash))
{
var message = string.Format(CultureInfo.CurrentCulture, Strings.Error_PackageValidationFailed, difference.Key.Id + "." + difference.Key.ResolvedVersion);
var log = RestoreLogMessage.CreateError(NuGetLogCode.NU1403, message, packagesConfigFile);
log.ProjectPath = projectFile ?? packagesConfigFile;
errors.Add(log);
}
return(errors);
}
}
else
{
if (restoreLockedMode)
{
var errors = new List <IRestoreLogMessage>();
var log = RestoreLogMessage.CreateError(NuGetLogCode.NU1004, Strings.Error_RestoreInLockedModePackagesConfig, packagesConfigFile);
log.ProjectPath = projectFile ?? packagesConfigFile;
errors.Add(log);
return(errors);
}
else
{
PackagesLockFileFormat.Write(lockFilePath, projectLockFileEquivalent);
return(null);
}
}
}
}
else
{
return(null);
}
}
private async Task CommitAssetsFileAsync(
LockFileFormat lockFileFormat,
IRestoreResult result,
ILogger log,
bool toolCommit,
CancellationToken token)
{
// Commit targets/props to disk before the assets file.
// Visual Studio typically watches the assets file for changes
// and begins a reload when that file changes.
var buildFilesToWrite = result.MSBuildOutputFiles
.Where(e => BuildAssetsUtils.HasChanges(e.Content, e.Path, log));
BuildAssetsUtils.WriteFiles(buildFilesToWrite, log);
if (result.LockFile == null || result.LockFilePath == null)
{
// there is no assets file to be written so just return
return;
}
// Avoid writing out the lock file if it is the same to avoid triggering an intellisense
// update on a restore with no actual changes.
if (result.PreviousLockFile == null ||
!result.PreviousLockFile.Equals(result.LockFile))
{
if (toolCommit)
{
log.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Log_ToolWritingLockFile,
result.LockFilePath));
await FileUtility.ReplaceWithLock(
(outputPath) => lockFileFormat.Write(outputPath, result.LockFile),
result.LockFilePath);
}
else
{
log.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Log_WritingLockFile,
result.LockFilePath));
FileUtility.Replace(
(outputPath) => lockFileFormat.Write(outputPath, result.LockFile),
result.LockFilePath);
if (NewPackagesLockFile != null && !string.IsNullOrEmpty(NewPackagesLockFilePath))
{
log.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Log_WritingPackagesLockFile,
NewPackagesLockFilePath));
FileUtility.Replace(
(outputPath) => PackagesLockFileFormat.Write(outputPath, NewPackagesLockFile),
NewPackagesLockFilePath);
}
}
}
else
{
if (toolCommit)
{
log.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Log_ToolSkippingAssetsFile,
result.LockFilePath));
}
else
{
log.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Log_SkippingAssetsFile,
result.LockFilePath));
}
}
}