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)); } } }