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