public void NotifyProjectReferencesChanged_DoNotIncludeTransitiveReferences_NotifyReferencesChangedEventFiredForMainProjectOnly() { CreateNuGetProject(); var dotNetProjectWithProjectReference = CreateDotNetCoreProject("MyProject2", @"d:\projects\MyProject2\MyProject2.csproj"); dotNetProject.ParentSolution.RootFolder.AddItem(dotNetProjectWithProjectReference); var projectReference = ProjectReference.CreateProjectReference(dotNetProject); dotNetProjectWithProjectReference.References.Add(projectReference); string modifiedHintMainProject = null; dotNetProject.Modified += (sender, e) => { modifiedHintMainProject = e.Single().Hint; }; string modifiedHintProjectWithReference = null; dotNetProjectWithProjectReference.Modified += (sender, e) => { modifiedHintProjectWithReference = e.Single().Hint; }; project.NotifyProjectReferencesChanged(false); Assert.AreEqual("References", modifiedHintMainProject); Assert.IsNull(modifiedHintProjectWithReference); }
public async Task GetPackageSpecsAsync_ProjectHasOneProjectReference_RestoreMetadataHasProjectReference() { FilePath directory = Util.CreateTmpDir("ProjectJsonNuGetTests"); string expectedProjectFileName = directory.Combine("ReferencedProject.csproj"); var projectToBeReferenced = CreateDotNetProject("ReferencedProject", expectedProjectFileName); string mainProjectFileName = directory.Combine("MainTest.csproj"); var mainProject = CreateDotNetProject("MainTest", mainProjectFileName); CreateSolution(mainProject, projectToBeReferenced); var projectReference = ProjectReference.CreateProjectReference(projectToBeReferenced); mainProject.References.Add(projectReference); CreateProjectJsonNuGetProject(mainProject); var context = new DependencyGraphCacheContext(); var specs = await projectJsonNuGetProject.GetPackageSpecsAsync(context); var spec = specs [0]; var targetFramework = spec.RestoreMetadata.TargetFrameworks.FirstOrDefault(); Assert.AreEqual(1, specs.Count); Assert.AreEqual(1, spec.RestoreMetadata.TargetFrameworks.Count); Assert.AreEqual(1, targetFramework.ProjectReferences.Count); Assert.AreEqual(expectedProjectFileName, targetFramework.ProjectReferences [0].ProjectPath); }
public async Task PostProcessAsync_DotNetCoreProjectReferencesThisProjectLockFileNotChanged_NotifyReferencesChangedEventFiredForBothProjects() { CreateNuGetProject(); AddDotNetProjectPackageReference("NUnit", "2.6.0"); var dotNetProjectWithProjectReference = CreateDotNetCoreProject("MyProject2", @"d:\projects\MyProject2\MyProject2.csproj"); dotNetProject.ParentSolution.RootFolder.AddItem(dotNetProjectWithProjectReference); var projectReference = ProjectReference.CreateProjectReference(dotNetProject); dotNetProjectWithProjectReference.References.Add(projectReference); string modifiedHintMainProject = null; dotNetProject.Modified += (sender, e) => { modifiedHintMainProject = e.Single().Hint; }; string modifiedHintProjectWithReference = null; dotNetProjectWithProjectReference.Modified += (sender, e) => { modifiedHintProjectWithReference = e.Single().Hint; }; OnAfterExecuteActions("NUnit", "2.6.3", NuGetProjectActionType.Install); await project.PostProcessAsync(context, CancellationToken.None); Assert.AreEqual(project, buildIntegratedRestorer.ProjectRestored); Assert.AreEqual("References", modifiedHintMainProject); Assert.AreEqual("References", modifiedHintProjectWithReference); }
public void GetProjectReferencesAsync_ExceptionThrownWhenResolvingProject_ErrorLogged() { var projectToBeReferenced = CreateDotNetProject("Test"); var mainProject = CreateDotNetProject("MyProject"); var projectReference = ProjectReference.CreateProjectReference(projectToBeReferenced); // Project has no parent solution - which will cause an exception. mainProject.References.Add(projectReference); CreateProjectReferencesReader(mainProject); var messagesLogged = new List <PackageOperationMessage> (); packageManagementEvents.PackageOperationMessageLogged += (sender, e) => { messagesLogged.Add(e.Message); }; var references = GetProjectReferences(); string expectedMessage = "Failed to resolve all project references. The package restore result for 'MyProject' or a dependant project may be incomplete."; Assert.AreEqual(0, references.Count); Assert.AreEqual(2, messagesLogged.Count); Assert.AreEqual(MessageLevel.Debug, messagesLogged [0].Level); Assert.That(messagesLogged [0].ToString(), Contains.Substring("ArgumentNullException")); Assert.AreEqual(MessageLevel.Warning, messagesLogged [1].Level); Assert.AreEqual(expectedMessage, messagesLogged [1].ToString()); }
internal protected override void OnReadProject(ProgressMonitor monitor, MSBuildProject msproject) { base.OnReadProject(monitor, msproject); // Convert .projitems imports into project references foreach (var sp in msproject.Imports.Where(im => im.Label == "Shared" && im.Project.EndsWith(".projitems"))) { var projitemsFile = sp.Project; if (!string.IsNullOrEmpty(projitemsFile)) { projitemsFile = MSBuildProjectService.FromMSBuildPath(Project.ItemDirectory, projitemsFile); projitemsFile = Path.Combine(Path.GetDirectoryName(msproject.FileName), projitemsFile); if (File.Exists(projitemsFile)) { using (MSBuildProject p = new MSBuildProject(msproject.EngineManager)) { p.Load(projitemsFile); Project.LoadProjectItems(p, ProjectItemFlags.Hidden | ProjectItemFlags.DontPersist, null); var r = ProjectReference.CreateProjectReference(projitemsFile); r.Flags = ProjectItemFlags.DontPersist; r.SetItemsProjectPath(projitemsFile); Project.References.Add(r); } } } } }
public void AddReference(object sender, Gtk.ToggledArgs e) { Gtk.TreeIter iter; store.GetIterFromString(out iter, e.Path); ReferenceType rt = (ReferenceType)store.GetValue(iter, ColType); string fullName = (string)store.GetValue(iter, ColFullName); if ((bool)store.GetValue(iter, ColSelected) == false) { store.SetValue(iter, ColSelected, true); switch (rt) { case ReferenceType.Package: selectDialog.AddReference(ProjectReference.CreateAssemblyReference((SystemAssembly)store.GetValue(iter, ColAssembly))); break; case ReferenceType.Assembly: selectDialog.AddReference(ProjectReference.CreateAssemblyFileReference(fullName)); break; case ReferenceType.Project: selectDialog.AddReference(ProjectReference.CreateProjectReference(fullName)); break; } } else { store.SetValue(iter, ColSelected, false); selectDialog.RemoveReference(rt, fullName); } }
public void DotNetCoreNotifyReferencesChanged_TwoProjectReferencesChainToModifiedProject_NotifyReferencesChangedForAllProjects2() { var dotNetProject = CreateDotNetCoreProject(); AddParentSolution(dotNetProject); var referencingProject1 = CreateDotNetCoreProject(); var referencingProject2 = CreateDotNetCoreProject(); dotNetProject.ParentSolution.RootFolder.AddItem(referencingProject2); dotNetProject.ParentSolution.RootFolder.AddItem(referencingProject1); referencingProject1.References.Add(ProjectReference.CreateProjectReference(dotNetProject)); referencingProject2.References.Add(ProjectReference.CreateProjectReference(referencingProject1)); string modifiedHint = null; dotNetProject.Modified += (sender, e) => { modifiedHint = e.First().Hint; }; string modifiedHintForReferencingProject1 = null; referencingProject1.Modified += (sender, e) => { modifiedHintForReferencingProject1 = e.First().Hint; }; string modifiedHintForReferencingProject2 = null; referencingProject2.Modified += (sender, e) => { modifiedHintForReferencingProject2 = e.First().Hint; }; dotNetProject.DotNetCoreNotifyReferencesChanged(); Assert.AreEqual("References", modifiedHint); Assert.AreEqual("References", modifiedHintForReferencingProject1); Assert.AreEqual("References", modifiedHintForReferencingProject2); }
public void GetProjectReferencesAsync_OneInvalidProjectReference_NoProjectReferencesAndWarningLogged() { var projectToBeReferenced = CreateDotNetProject("Test"); var mainProject = CreateDotNetProject("MyProject"); CreateSolution(mainProject, projectToBeReferenced); var projectReference = ProjectReference.CreateProjectReference(projectToBeReferenced); // Mark project reference as invalid. projectReference.SetInvalid("Not valid"); mainProject.References.Add(projectReference); CreateProjectReferencesReader(mainProject); PackageOperationMessage messageLogged = null; packageManagementEvents.PackageOperationMessageLogged += (sender, e) => { messageLogged = e.Message; }; var references = GetProjectReferences(); string expectedMessage = "Failed to resolve all project references. The package restore result for 'MyProject' or a dependant project may be incomplete."; Assert.AreEqual(0, references.Count); Assert.IsNotNull(messageLogged); Assert.AreEqual(MessageLevel.Warning, messageLogged.Level); Assert.AreEqual(expectedMessage, messageLogged.ToString()); }
void CombineOpened(object sender, SolutionEventArgs args) { if (args.Solution == Project.ParentSolution) { foreach (string pref in refNames) { Project p = Project.ParentSolution.FindProjectByName(pref); if (p != null) { Project.References.Add(ProjectReference.CreateProjectReference(p)); } } } }
public void GetProjectReferencesAsync_OneSharedAssetProjectReference_SharedProjectIsNotIncluded() { var projectToBeReferenced = new SharedAssetsProject("C#"); var mainProject = CreateDotNetProject(); CreateSolution(mainProject, projectToBeReferenced); var projectReference = ProjectReference.CreateProjectReference(projectToBeReferenced); mainProject.References.Add(projectReference); CreateProjectReferencesReader(mainProject); var references = GetProjectReferences(); Assert.AreEqual(0, references.Count); }
void ProcessProject(DotNetProject p) { // When the projitems file name doesn't match the shproj file name, the reference we add to the referencing projects // uses the projitems name, not the shproj name. Here we detect such case and re-add the references using the correct name var referencesToFix = p.References.Where(r => r.GetItemsProjectPath() == ProjItemsPath && r.Reference != Name).ToList(); foreach (var r in referencesToFix) { p.References.Remove(r); p.References.Add(ProjectReference.CreateProjectReference(this)); } foreach (var pref in p.References.Where(r => r.ReferenceType == ReferenceType.Project && r.Reference == Name)) { ProcessNewReference(pref); } }
public void GetProjectReferencesAsync_OneProjectReferenceWithReferenceOutputAssemblyFalse_NoProjectReferences() { var projectToBeReferenced = CreateDotNetProject("Test"); var mainProject = CreateDotNetProject(); CreateSolution(mainProject, projectToBeReferenced); var projectReference = ProjectReference.CreateProjectReference(projectToBeReferenced); // Do not reference output assembly of project. projectReference.ReferenceOutputAssembly = false; mainProject.References.Add(projectReference); CreateProjectReferencesReader(mainProject); var references = GetProjectReferences(); Assert.AreEqual(0, references.Count); }
public void AddReference(object sender, Gtk.ToggledArgs e) { Gtk.TreeIter iter; store.GetIterFromString(out iter, e.Path); Project project = (Project)store.GetValue(iter, 2); if ((bool)store.GetValue(iter, ColSelected) == false) { store.SetValue(iter, ColSelected, true); selectDialog.AddReference(ProjectReference.CreateProjectReference(project)); } else { store.SetValue(iter, ColSelected, false); selectDialog.RemoveReference(ReferenceType.Project, project.Name); } }
public void GetReferencingProjects_ThreeProjectsOneProjectReferencesModifiedProject_OneProjectReturned() { var dotNetProject = CreateDotNetCoreProject(); AddParentSolution(dotNetProject); var referencedProject = CreateDotNetCoreProject(); dotNetProject.ParentSolution.RootFolder.AddItem(referencedProject); referencedProject.References.Add(ProjectReference.CreateProjectReference(dotNetProject)); var otherProject = CreateDotNetCoreProject(); dotNetProject.ParentSolution.RootFolder.AddItem(otherProject); var projects = dotNetProject.GetReferencingProjects().ToList(); Assert.AreEqual(1, projects.Count); Assert.AreEqual(projects[0], referencedProject); }
public void GetProjectReferencesAsync_OneProjectReference_ReturnedInProjectReferences() { string expectedProjectFileName = @"d:\projects\Test\MyTest.csproj".ToNativePath(); var projectToBeReferenced = CreateDotNetProject("Test", expectedProjectFileName); var mainProject = CreateDotNetProject(); CreateSolution(mainProject, projectToBeReferenced); var projectReference = ProjectReference.CreateProjectReference(projectToBeReferenced); mainProject.References.Add(projectReference); CreateProjectReferencesReader(mainProject); var references = GetProjectReferences(); Assert.AreEqual(1, references.Count); Assert.AreEqual(expectedProjectFileName, references [0].ProjectPath); Assert.AreEqual(expectedProjectFileName, references [0].ProjectUniqueName); }
public void IncludeTransitiveProjectReferences_ThreeProjectsOneReferencedAnother_TwoProjectsRestored() { CreateProject(); var referencingProject = CreateDotNetCoreProject(); dotNetProject.ParentSolution.RootFolder.AddItem(referencingProject); referencingProject.References.Add(ProjectReference.CreateProjectReference(dotNetProject)); var otherProject = CreateDotNetCoreProject(); dotNetProject.ParentSolution.RootFolder.AddItem(otherProject); var referencingNuGetProject = CreateNuGetProject(referencingProject); CreateAction(true); action.Execute(); Assert.AreEqual(2, buildIntegratedRestorer.ProjectsRestored.Count); Assert.AreEqual(buildIntegratedRestorer.ProjectsRestored[0], nugetProject); Assert.AreEqual(buildIntegratedRestorer.ProjectsRestored[1], referencingNuGetProject); }
public void DotNetCoreNotifyReferencesChanged_OneProjectReferencesProjectWithReferencedOutputAssemblyFalse_NotifyReferencesChangedNotFiredForReferencingProject() { var dotNetProject = CreateDotNetCoreProject(); AddParentSolution(dotNetProject); var referencingProject = CreateDotNetCoreProject(); dotNetProject.ParentSolution.RootFolder.AddItem(referencingProject); var projectReference = ProjectReference.CreateProjectReference(dotNetProject); projectReference.ReferenceOutputAssembly = false; referencingProject.References.Add(projectReference); string modifiedHintForReferencingProject = null; referencingProject.Modified += (sender, e) => { modifiedHintForReferencingProject = e.First().Hint; }; dotNetProject.DotNetCoreNotifyReferencesChanged(true); Assert.IsNull(modifiedHintForReferencingProject); }
public void GetReferencingProjects_TwoProjectReferencesChainToModifiedProject_NotifyReferencesChangedForAllProjects() { var dotNetProject = CreateDotNetCoreProject(); AddParentSolution(dotNetProject); var referencingProject1 = CreateDotNetCoreProject(); dotNetProject.ParentSolution.RootFolder.AddItem(referencingProject1); referencingProject1.References.Add(ProjectReference.CreateProjectReference(dotNetProject)); var referencingProject2 = CreateDotNetCoreProject(); dotNetProject.ParentSolution.RootFolder.AddItem(referencingProject2); referencingProject2.References.Add(ProjectReference.CreateProjectReference(referencingProject1)); var otherProject = CreateDotNetCoreProject(); dotNetProject.ParentSolution.RootFolder.AddItem(otherProject); var projects = dotNetProject.GetReferencingProjects().ToList(); Assert.AreEqual(2, projects.Count); Assert.That(projects, Contains.Item(referencingProject1)); Assert.That(projects, Contains.Item(referencingProject2)); }
public async override void OnNodeDrop(object dataObject, DragOperation operation) { // It allows dropping either project references or projects. // Dropping a project creates a new project reference to that project DotNetProject project = dataObject as DotNetProject; if (project != null) { ProjectReference pr = ProjectReference.CreateProjectReference(project); DotNetProject p = CurrentNode.GetParentDataItem(typeof(DotNetProject), false) as DotNetProject; // Circular dependencies are not allowed. if (HasCircularReference(project, p.Name)) { return; } // If the reference already exists, bail out if (ProjectReferencesProject(p, project.Name)) { return; } p.References.Add(pr); await IdeApp.ProjectOperations.SaveAsync(p); return; } // It's dropping a ProjectReference object. ProjectReference pref = dataObject as ProjectReference; ITreeNavigator nav = CurrentNode; if (operation == DragOperation.Move) { NodePosition pos = nav.CurrentPosition; nav.MoveToObject(dataObject); DotNetProject p = nav.GetParentDataItem(typeof(DotNetProject), true) as DotNetProject; nav.MoveToPosition(pos); DotNetProject p2 = nav.GetParentDataItem(typeof(DotNetProject), true) as DotNetProject; p.References.Remove(pref); // Check if there is a cyclic reference after removing from the source project if (pref.ReferenceType == ReferenceType.Project) { DotNetProject pdest = pref.ResolveProject(p.ParentSolution) as DotNetProject; if (pdest == null || ProjectReferencesProject(pdest, p2.Name)) { // Restore the dep p.References.Add(pref); return; } } p2.References.Add(pref); await IdeApp.ProjectOperations.SaveAsync(p); await IdeApp.ProjectOperations.SaveAsync(p2); } else { nav.MoveToParent(typeof(DotNetProject)); DotNetProject p = nav.DataItem as DotNetProject; // Check for cyclic referencies if (pref.ReferenceType == ReferenceType.Project) { DotNetProject pdest = pref.ResolveProject(p.ParentSolution) as DotNetProject; if (pdest == null) { return; } if (HasCircularReference(pdest, p.Name)) { return; } // The reference is already there if (ProjectReferencesProject(p, pdest.Name)) { return; } } p.References.Add((ProjectReference)pref.Clone()); await IdeApp.ProjectOperations.SaveAsync(p); } }
void AddProjectReference(DotNetProject project, Project projectToBeReferenced) { project.References.Add(ProjectReference.CreateProjectReference(projectToBeReferenced)); }