/// <summary> /// Project.json based project system. /// </summary> /// <param name="jsonConfig">Path to project.json.</param> /// <param name="msBuildProjectPath">Path to the msbuild project file.</param> public ProjectJsonBuildIntegratedNuGetProject( string jsonConfig, string msBuildProjectPath) { if (jsonConfig == null) { throw new ArgumentNullException(nameof(jsonConfig)); } if (msBuildProjectPath == null) { throw new ArgumentNullException(nameof(msBuildProjectPath)); } _jsonConfig = new FileInfo(jsonConfig); MSBuildProjectPath = msBuildProjectPath; _projectName = Path.GetFileNameWithoutExtension(msBuildProjectPath); if (string.IsNullOrEmpty(_projectName)) { throw new ArgumentException( string.Format(CultureInfo.CurrentCulture, Strings.InvalidProjectName, MSBuildProjectPath)); } JObject projectJson; IEnumerable <NuGetFramework> targetFrameworks = Enumerable.Empty <NuGetFramework>(); try { projectJson = GetJson(); targetFrameworks = JsonConfigUtility.GetFrameworks(projectJson); } catch (InvalidOperationException) { // Ignore a bad project.json when constructing the project, and treat it as unsupported. } // Default to unsupported if anything unexpected is returned var targetFramework = NuGetFramework.UnsupportedFramework; // Having more than one framework is not supported, but we pick the first as fallback // We will eventually support more than one framework ala projectK. if (targetFrameworks.Count() == 1) { targetFramework = targetFrameworks.First(); } InternalMetadata.Add(NuGetProjectMetadataKeys.TargetFramework, targetFramework); InternalMetadata.Add(NuGetProjectMetadataKeys.Name, _projectName); InternalMetadata.Add(NuGetProjectMetadataKeys.FullPath, msBuildProjectPath); var supported = new List <FrameworkName> { new FrameworkName(targetFramework.DotNetFrameworkName) }; InternalMetadata.Add(NuGetProjectMetadataKeys.SupportedFrameworks, supported); }
public override async Task <bool> InstallPackageAsync( PackageIdentity packageIdentity, DownloadResourceResult downloadResourceResult, INuGetProjectContext nuGetProjectContext, CancellationToken token) { var dependency = new PackageDependency(packageIdentity.Id, new VersionRange(packageIdentity.Version)); var json = await GetJsonAsync(); JsonConfigUtility.AddDependency(json, dependency); await SaveJsonAsync(json); var packageReader = downloadResourceResult.PackageReader ?? new PackageArchiveReader(downloadResourceResult.PackageStream, leaveStreamOpen: true); IAsyncPackageContentReader packageContentReader = packageReader; IAsyncPackageCoreReader packageCoreReader = packageReader; var libItemGroups = await packageContentReader.GetLibItemsAsync(token); var referenceItemGroups = await packageContentReader.GetReferenceItemsAsync(token); var frameworkReferenceGroups = await packageContentReader.GetFrameworkItemsAsync(token); var contentFileGroups = await packageContentReader.GetContentItemsAsync(token); var buildFileGroups = await packageContentReader.GetBuildItemsAsync(token); var toolItemGroups = await packageContentReader.GetToolItemsAsync(token); var depsGroups = await packageContentReader.GetPackageDependenciesAsync(token); IEnumerable <FrameworkSpecificGroup> refItemGroups = null; if (packageReader is PackageArchiveReader reader) { refItemGroups = await reader.GetItemsAsync(PackagingConstants.Folders.Ref, token); } else if (packageReader is PackageFolderReader reader2) { refItemGroups = await reader2.GetItemsAsync(PackagingConstants.Folders.Ref, token); } var deps = (PackageDependencyInfo)NuGetProjectActions.First(x => x.PackageIdentity.Equals(packageIdentity)).PackageIdentity; var entry = new WorkspaceEntry(packageIdentity, GetSha(downloadResourceResult.PackageStream), depsGroups, libItemGroups, toolItemGroups, refItemGroups, _mainFile); if (!SdkList.Dlls.Contains(entry.PackageIdentity.Id.ToLower())) { var workspace = await GetWorkspaceAsync(); var updater = new WorkspaceWriter(); var updated = updater.AddEntry(workspace, entry); await SaveWorkspaceAsync(updated); } return(await base.InstallPackageAsync(packageIdentity, downloadResourceResult, nuGetProjectContext, token)); }
public void JsonConfigUtility_AddDependencyToNewFile() { // Arrange var json = BasicConfig; // Act JsonConfigUtility.AddDependency(json, new PackageDependency("testpackage", VersionRange.Parse("1.0.0"))); // Assert Assert.Equal("1.0.0", json["dependencies"]["testpackage"].ToString()); }
public void JsonConfigUtility_GetTargetFramework() { // Arrange var json = BasicConfig; // Act var frameworks = JsonConfigUtility.GetFrameworks(json); // Assert Assert.Equal("netcore50", frameworks.Single().GetShortFolderName()); }
public async Task <bool> AddDependency(PackageDependency dependency, CancellationToken token) { var json = await GetJsonAsync(); JsonConfigUtility.AddDependency(json, dependency); await SaveJsonAsync(json); return(true); }
public async Task <bool> RemoveDependency(string packageId, INuGetProjectContext nuGetProjectContext, CancellationToken token) { var json = await GetJsonAsync(); JsonConfigUtility.RemoveDependency(json, packageId); await SaveJsonAsync(json); return(true); }
public static PackageReference CreatePackageReferenceWithProjectJsonWildcardVersion( string package, string version) { string json = "{ \"dependencies\": { \"" + package + "\": \"" + version + "\" } }"; var jsonObject = JObject.Parse(json); var dependency = JsonConfigUtility.GetDependencies(jsonObject).First(); var identity = new PackageIdentity(dependency.Id, dependency.VersionRange.MinVersion); return(new PackageReference(identity, null, true, false, false, dependency.VersionRange)); }
public override bool Execute() { var fullPath = ProjectJsonPath.GetMetadata("FullPath"); using (var reader = new StreamReader(fullPath)) { var json = JObject.Parse(reader.ReadToEnd()); PackageReferences = JsonConfigUtility.GetDependencies(json) .Select(ConvertToTaskItem) .ToArray(); } return(true); }
private void UpdateFramework(JObject json) { var frameworks = JsonConfigUtility.GetFrameworks(json); if (InternalMetadata.TryGetValue(NuGetProjectMetadataKeys.TargetFramework, out object newTargetFramework)) { if (IsUAPFramework(newTargetFramework as NuGetFramework) && frameworks.Count() == 1) { // project.json can have only one target framework JsonConfigUtility.ClearFrameworks(json); JsonConfigUtility.AddFramework(json, newTargetFramework as NuGetFramework); } } }
public void JsonConfigUtility_RemoveDependencyFromNewFile() { // Arrange var json = BasicConfig; // Act JsonConfigUtility.RemoveDependency(json, "testpackage"); JToken val = null; json.TryGetValue("dependencies", out val); // Assert Assert.Null(val); }
public void JsonConfigUtility_AddFramework() { // Arrange var json = BasicConfig; var frameworks = JsonConfigUtility.GetFrameworks(json); Assert.Equal(1, frameworks.Count()); // Act JsonConfigUtility.AddFramework(json, new NuGet.Frameworks.NuGetFramework("uap", new Version("10.0.0"))); frameworks = JsonConfigUtility.GetFrameworks(json); //Assert Assert.Equal(2, frameworks.Count()); }
public void JsonConfigUtility_ClearFrameworks() { // Arrange var json = BasicConfig; var frameworks = JsonConfigUtility.GetFrameworks(json); Assert.Equal("netcore50", frameworks.Single().GetShortFolderName()); // Act JsonConfigUtility.ClearFrameworks(json); frameworks = JsonConfigUtility.GetFrameworks(json); //Assert Assert.Equal(0, frameworks.Count()); }
public async override Task <bool> InstallPackageAsync( string packageId, VersionRange range, INuGetProjectContext nuGetProjectContext, BuildIntegratedInstallationContext installationContext, CancellationToken token) { var dependency = new PackageDependency(packageId, range); var json = await GetJsonAsync(); JsonConfigUtility.AddDependency(json, dependency); await SaveJsonAsync(json); return(true); }
public void GetDependencies_ThrowsIfObjectDoesNotHaveVersionProperty() { // Arrange var json = JObject.Parse( @" { ""dependencies"": { ""PackageA"": { ""type"": ""build"" } } }"); // Act and Assert var ex = Assert.Throws <FormatException>(() => JsonConfigUtility.GetDependencies(json).ToList()); // Assert Assert.Equal($"Dependency '{json["dependencies"].First}' has invalid version specification.", ex.Message); }
public void GetDependencies_ThrowsIfVersionIsAnEmptyString() { // Arrange var json = JObject.Parse( @" { ""dependencies"": { ""PackageA"": """" } }"); // Act and Assert var ex = Assert.Throws <FormatException>(() => JsonConfigUtility.GetDependencies(json).ToList()); // Assert Assert.Equal("Dependency '\"PackageA\": \"\"' has invalid version specification.", ex.Message); }
private async Task UpdateFrameworkAsync(JObject json) { // Update the internal target framework with TPMinV from csproj await UpdateInternalTargetFrameworkAsync(); if (TryGetInternalFramework(out object newTargetFrameworkObject)) { var frameworks = JsonConfigUtility.GetFrameworks(json); var newTargetFramework = newTargetFrameworkObject as NuGetFramework; if (IsUAPFramework(newTargetFramework) && frameworks.Count() == 1 && frameworks.Single() != newTargetFramework) { // project.json can have only one target framework JsonConfigUtility.ClearFrameworks(json); JsonConfigUtility.AddFramework(json, newTargetFramework as NuGetFramework); } } }
public override async Task <bool> UninstallPackageAsync( PackageIdentity packageIdentity, INuGetProjectContext nuGetProjectContext, CancellationToken token) { var json = await GetJsonAsync(); JsonConfigUtility.RemoveDependency(json, packageIdentity.Id); await SaveJsonAsync(json); var workspace = await GetWorkspaceAsync(); var updater = new WorkspaceWriter(); var updated = updater.RemoveEntry(workspace, packageIdentity.Id); await SaveWorkspaceAsync(updated); return(await base.UninstallPackageAsync(packageIdentity, nuGetProjectContext, token)); }
public override async Task <IEnumerable <PackageReference> > GetInstalledPackagesAsync(CancellationToken token) { var packages = new List <PackageReference>(); // Find all dependencies and convert them into packages.config style references foreach (var dependency in JsonConfigUtility.GetDependencies(await GetJsonAsync())) { // Use the minimum version of the range for the identity var identity = new PackageIdentity(dependency.Id, dependency.VersionRange.MinVersion); // Pass the actual version range as the allowed range packages.Add(new PackageReference(identity, targetFramework: null, userInstalled: true, developmentDependency: false, requireReinstallation: false, allowedVersions: dependency.VersionRange)); } return(packages); }
public OneDasPackageManager(IExtensionFactory extensionFactory, IOptions <OneDasOptions> options, ILoggerFactory loggerFactory) { JObject jobject; VersionRange versionRange; _extensionFactory = extensionFactory; _options = options.Value; // settings _settings = new Settings(_options.NugetDirectoryPath); _settings.SetValues(ConfigurationConstants.PackageSources, new List <SettingValue>() { new SettingValue("NuGet", "https://api.nuget.org/v3/index.json", false) }); _settings.SetValues(ConfigurationConstants.PackageSources, new List <SettingValue>() { new SettingValue("MyGet (CI)", "https://www.myget.org/F/onedas/api/v3/index.json", false) }); if (!File.Exists(_options.NugetProjectFilePath)) { jobject = new JObject(); versionRange = new VersionRange(new NuGetVersion("2.0.3")); JsonConfigUtility.AddFramework(jobject, FrameworkConstants.CommonFrameworks.NetStandard20); JsonConfigUtility.AddDependency(jobject, new PackageDependency("NETStandard.Library", versionRange)); jobject.Add("runtimes", new JObject(new JProperty(_options.RestoreRuntimeId, new JObject()))); File.WriteAllText(_options.NugetProjectFilePath, jobject.ToString(Formatting.Indented)); } _project = new OneDasNugetProject(_options.NugetProjectFilePath); _projectContext = new OneDasNuGetProjectContext(loggerFactory.CreateLogger("Nuget")); _sourceRepositoryProvider = this.CreateSourceRepositoryProvider(); _packageManager = this.CreateNuGetPackageManager(_sourceRepositoryProvider); this.PackageSourceSet = SettingsUtility.GetEnabledSources(_settings).ToList(); }
public void JsonConfigUtility_VerifyPackagesAreSortedInProjectJson() { // Arrange var json = BasicConfig; // Act JsonConfigUtility.AddDependency(json, new PackageDependency("testpackageb", VersionRange.Parse("1.0.0"))); JsonConfigUtility.AddDependency(json, new PackageDependency("testpackageE", VersionRange.Parse("2.0.0"))); JsonConfigUtility.AddDependency(json, new PackageDependency("testpackageA", VersionRange.Parse("1.0.0"))); JsonConfigUtility.AddDependency(json, new PackageDependency("testpackaged", VersionRange.Parse("4.0.0"))); JsonConfigUtility.AddDependency(json, new PackageDependency("testpackageC", VersionRange.Parse("1.0.0"))); JToken val = null; json.TryGetValue("dependencies", out val); // Assert Assert.Equal("testpackageA", ((JProperty)json["dependencies"].Children().First()).Name); Assert.Equal("testpackageb", ((JProperty)json["dependencies"].Children().Skip(1).First()).Name); Assert.Equal("testpackageC", ((JProperty)json["dependencies"].Children().Skip(2).First()).Name); Assert.Equal("testpackaged", ((JProperty)json["dependencies"].Children().Skip(3).First()).Name); Assert.Equal("testpackageE", ((JProperty)json["dependencies"].Children().Skip(4).First()).Name); }
public void GetDependencies_ParsesIdAndVersion() { // Arrange var json = JObject.Parse( @" { ""dependencies"": { ""PackageA"": ""1.0.0"", ""PackageC"": { ""type"": ""build"", version: ""2.0.0-beta2"" } } }"); // Act var dependencies = JsonConfigUtility.GetDependencies(json).ToList(); // Assert Assert.Equal(2, dependencies.Count); Assert.Equal("PackageA", dependencies[0].Id); Assert.Equal(VersionRange.Parse("1.0.0"), dependencies[0].VersionRange); Assert.Equal("PackageC", dependencies[1].Id); Assert.Equal(VersionRange.Parse("2.0.0-beta2"), dependencies[1].VersionRange); }
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredMissingPackage() { // Arrange var projectName = "testproj"; using (var solutionManager = new TestSolutionManager(false)) { var projectFolder = new DirectoryInfo(Path.Combine(solutionManager.SolutionDirectory, projectName)); projectFolder.Create(); var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName); var json = JObject.Parse(File.ReadAllText(projectConfig.FullName)); JsonConfigUtility.AddDependency(json, new NuGet.Packaging.Core.PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7"))); using (var writer = new StreamWriter(projectConfig.FullName)) { writer.Write(json.ToString()); } var sources = new List <SourceRepository> { }; var projectTargetFramework = NuGetFramework.Parse("uap10.0"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName); solutionManager.NuGetProjects.Add(project); var testLogger = new TestLogger(); var settings = Settings.LoadSpecificSettings(solutionManager.SolutionDirectory, "NuGet.Config"); var restoreContext = new DependencyGraphCacheContext(testLogger, settings); var providersCache = new RestoreCommandProvidersCache(); await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), restoreContext, providersCache, (c) => { }, sources, Guid.Empty, false, true, testLogger, CancellationToken.None); var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), restoreContext, providersCache, (c) => { }, sources, Guid.Empty, false, true, testLogger, CancellationToken.None); foreach (var restoreSummary in noOpRestoreSummaries) { Assert.True(restoreSummary.NoOpRestore); } var resolver = new VersionFolderPathResolver(solutionManager.GlobalPackagesFolder); var pathToDelete = resolver.GetInstallPath("nuget.versioning", NuGetVersion.Parse("1.0.7")); TestFileSystemUtility.DeleteRandomTestFolder(pathToDelete); var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sources, Guid.Empty, false, true, testLogger, CancellationToken.None); foreach (var restoreSummary in restoreSummaries) { Assert.True(restoreSummary.Success); Assert.False(restoreSummary.NoOpRestore); } } }
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredChangedSha512() { // Arrange var projectName = "testproj"; using (var packagesFolder = TestDirectory.Create()) using (var rootFolder = TestDirectory.Create()) { var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName)); projectFolder.Create(); var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName); var json = JObject.Parse(File.ReadAllText(projectConfig.FullName)); JsonConfigUtility.AddDependency(json, new PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7"))); using (var writer = new StreamWriter(projectConfig.FullName)) { writer.Write(json.ToString()); } var sources = new List <SourceRepository> { Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/") }; var testLogger = new TestLogger(); var projectTargetFramework = NuGetFramework.Parse("uap10.0"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var project = new ProjectJsonBuildIntegratedNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName, msBuildNuGetProjectSystem); var solutionManager = new TestSolutionManager(false); solutionManager.NuGetProjects.Add(project); var restoreContext = new DependencyGraphCacheContext(testLogger); await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sources, packagesFolder, NullSettings.Instance, testLogger, CancellationToken.None); var resolver = new VersionFolderPathResolver(packagesFolder); var hashPath = resolver.GetHashPath("nuget.versioning", NuGetVersion.Parse("1.0.7")); using (var writer = new StreamWriter(hashPath)) { writer.Write("ANAWESOMELYWRONGHASH!!!"); } // Act var actual = await project.IsRestoreRequired( new[] { resolver }, new HashSet <PackageIdentity>(), restoreContext); // Assert Assert.True(actual); } }
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredChangedSha512() { // Arrange var projectName = "testproj"; using (var solutionManager = new TestSolutionManager(false)) { var projectFolder = new DirectoryInfo(Path.Combine(solutionManager.SolutionDirectory, projectName)); projectFolder.Create(); var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName); var json = JObject.Parse(File.ReadAllText(projectConfig.FullName)); JsonConfigUtility.AddDependency(json, new PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7"))); using (var writer = new StreamWriter(projectConfig.FullName)) { writer.Write(json.ToString()); } var sources = new List <SourceRepository> { }; var testLogger = new TestLogger(); var settings = Settings.LoadSpecificSettings(solutionManager.SolutionDirectory, "NuGet.Config"); var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName); solutionManager.NuGetProjects.Add(project); var restoreContext = new DependencyGraphCacheContext(testLogger, settings); var providersCache = new RestoreCommandProvidersCache(); var dgSpec1 = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext); await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, dgSpec1, restoreContext, providersCache, (c) => { }, sources, Guid.Empty, false, true, testLogger, CancellationToken.None); var dgSpec2 = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext); var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, dgSpec2, restoreContext, providersCache, (c) => { }, sources, Guid.Empty, false, true, testLogger, CancellationToken.None); foreach (var restoreSummary in noOpRestoreSummaries) { Assert.True(restoreSummary.NoOpRestore); } var resolver = new VersionFolderPathResolver(solutionManager.GlobalPackagesFolder); var hashPath = resolver.GetHashPath("nuget.versioning", NuGetVersion.Parse("1.0.7")); File.Delete(hashPath); var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sources, Guid.Empty, false, true, testLogger, CancellationToken.None); foreach (var restoreSummary in restoreSummaries) { Assert.True(restoreSummary.Success); Assert.False(restoreSummary.NoOpRestore); } var filePath = Path.Combine( NuGetEnvironment.GetFolderPath(NuGetFolderPath.Temp), "nuget-dg", "nugetSpec.dg"); Assert.True(File.Exists(filePath)); } }
public async Task BuildIntegratedNuGetProject_RestoreFailed_PersistDGSpecFile() { // Arrange var projectName = "testproj"; using (var packagesFolder = TestDirectory.Create()) using (var rootFolder = TestDirectory.Create()) { var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName)); projectFolder.Create(); var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName); var json = JObject.Parse(File.ReadAllText(projectConfig.FullName)); // invalid version for nuget.versioning package which will make this restore fail. JsonConfigUtility.AddDependency(json, new PackageDependency("nuget.versioning", VersionRange.Parse("3000.0.0"))); using (var writer = new StreamWriter(projectConfig.FullName)) { writer.Write(json.ToString()); } var sources = new List <SourceRepository> { }; var testLogger = new TestLogger(); var settings = new Settings(rootFolder); settings.SetValue(SettingsUtility.ConfigSection, "globalPackagesFolder", packagesFolder); var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName); var solutionManager = new TestSolutionManager(false); solutionManager.NuGetProjects.Add(project); var restoreContext = new DependencyGraphCacheContext(testLogger, settings); var providersCache = new RestoreCommandProvidersCache(); var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext); var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, restoreContext, providersCache, (c) => { }, sources, false, dgSpec, testLogger, CancellationToken.None); foreach (var restoreSummary in restoreSummaries) { Assert.False(restoreSummary.Success); } var filePath = Path.Combine( NuGetEnvironment.GetFolderPath(NuGetFolderPath.Temp), "nuget-dg", "nugetSpec.dg"); Assert.True(File.Exists(filePath)); } }
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredWithNoChangesFallbackFolder() { // Arrange var projectName = "testproj"; using (var globalFolder = TestDirectory.Create()) using (var fallbackFolder = TestDirectory.Create()) using (var rootFolder = TestDirectory.Create()) { var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName)); projectFolder.Create(); var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName); var json = JObject.Parse(File.ReadAllText(projectConfig.FullName)); JsonConfigUtility.AddDependency(json, new NuGet.Packaging.Core.PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7"))); using (var writer = new StreamWriter(projectConfig.FullName)) { writer.Write(json.ToString()); } var sources = new List <SourceRepository> { Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/") }; var projectTargetFramework = NuGetFramework.Parse("uap10.0"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName); // Restore to the fallback folder var solutionManager = new TestSolutionManager(false); solutionManager.NuGetProjects.Add(project); var testLogger = new TestLogger(); var restoreContext = new DependencyGraphCacheContext(testLogger, NullSettings.Instance); await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sources, false, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), testLogger, CancellationToken.None); var packageFolders = new List <string> { globalFolder, fallbackFolder }; // Act //var actual = await project.IsRestoreRequired( // packageFolders.Select(p => new VersionFolderPathResolver(p)), // new HashSet<PackageIdentity>(), // restoreContext); // Assert //Assert.False(actual); } }
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredChangedSha512() { // Arrange var projectName = "testproj"; using (var packagesFolder = TestDirectory.Create()) using (var rootFolder = TestDirectory.Create()) { var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName)); projectFolder.Create(); var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName); var json = JObject.Parse(File.ReadAllText(projectConfig.FullName)); JsonConfigUtility.AddDependency(json, new PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7"))); using (var writer = new StreamWriter(projectConfig.FullName)) { writer.Write(json.ToString()); } var sources = new List <SourceRepository> { }; var testLogger = new TestLogger(); var settings = new Settings(rootFolder); settings.SetValue(SettingsUtility.ConfigSection, "globalPackagesFolder", packagesFolder); var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName); var solutionManager = new TestSolutionManager(false); solutionManager.NuGetProjects.Add(project); var restoreContext = new DependencyGraphCacheContext(testLogger, settings); var providersCache = new RestoreCommandProvidersCache(); var dgSpec1 = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext); await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, restoreContext, providersCache, (c) => { }, sources, false, dgSpec1, testLogger, CancellationToken.None); var dgSpec2 = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext); var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, restoreContext, providersCache, (c) => { }, sources, false, dgSpec2, testLogger, CancellationToken.None); foreach (var restoreSummary in noOpRestoreSummaries) { Assert.True(restoreSummary.NoOpRestore); } var resolver = new VersionFolderPathResolver(packagesFolder); var hashPath = resolver.GetHashPath("nuget.versioning", NuGetVersion.Parse("1.0.7")); using (var writer = new StreamWriter(hashPath)) { writer.Write("ANAWESOMELYWRONGHASH!!!"); } var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, restoreContext, new RestoreCommandProvidersCache(), (c) => { }, sources, false, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), testLogger, CancellationToken.None); foreach (var restoreSummary in restoreSummaries) { Assert.True(restoreSummary.Success); Assert.False(restoreSummary.NoOpRestore); } } }
public async Task BuildIntegratedNuGetProject_IsRestoreRequiredWithNoChanges() { // Arrange var projectName = "testproj"; using (var packagesFolder = TestDirectory.Create()) using (var rootFolder = TestDirectory.Create()) { var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName)); projectFolder.Create(); var projectConfig = new FileInfo(Path.Combine(projectFolder.FullName, "project.json")); var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj")); BuildIntegrationTestUtility.CreateConfigJson(projectConfig.FullName); var json = JObject.Parse(File.ReadAllText(projectConfig.FullName)); JsonConfigUtility.AddDependency(json, new NuGet.Packaging.Core.PackageDependency("nuget.versioning", VersionRange.Parse("1.0.7"))); using (var writer = new StreamWriter(projectConfig.FullName)) { writer.Write(json.ToString()); } var sources = new List <SourceRepository> { Repository.Factory.GetVisualStudio("https://www.nuget.org/api/v2/") }; var projectTargetFramework = NuGetFramework.Parse("uap10.0"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var project = new ProjectJsonNuGetProject(projectConfig.FullName, msbuildProjectPath.FullName); var effectiveGlobalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(NullSettings.Instance); var solutionManager = new TestSolutionManager(false); solutionManager.NuGetProjects.Add(project); var testLogger = new TestLogger(); var settings = new Settings(rootFolder); settings.SetValue(SettingsUtility.ConfigSection, "globalPackagesFolder", packagesFolder); var providersCache = new RestoreCommandProvidersCache(); var restoreContext = new DependencyGraphCacheContext(testLogger, settings); await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, restoreContext, providersCache, (c) => { }, sources, false, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), testLogger, CancellationToken.None); var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync( solutionManager, restoreContext, providersCache, (c) => { }, sources, false, await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext), testLogger, CancellationToken.None); foreach (var restoreSummary in noOpRestoreSummaries) { Assert.True(restoreSummary.NoOpRestore); } } }