public async Task When_Two_Roots()
{
using (var workspace = WorkspaceUtils.GetSubjectSolution())
{
var project = workspace.CurrentSolution.Projects.Single(p => p.Name == "SubjectSolution");
var graph = await NodeGraph.BuildGraph(CompilationCache.CacheWithSolution(workspace.CurrentSolution), ct : default);
var someClassNode = graph.Nodes[TypeNodeKey.GetFromFullName("SubjectSolution.SomeClass")];
var someCircularClassNode = graph.Nodes[TypeNodeKey.GetFromFullName("SubjectSolution.SomeCircularClass")];
var roots = new HashSet <Node>();
roots.Add(someClassNode);
roots.Add(someCircularClassNode);
var paths = NodeGraphExtensions.GetMultiDependencyRootPaths(graph, roots).ToArray();
var path = paths.Single();
Assert.AreEqual(someClassNode, path.Source);
Assert.AreEqual(someCircularClassNode, path.Target);
Assert.AreEqual(2, path.Intermediates.Count);
Assert.AreEqual("SomeOtherClass", (path.Intermediates[0] as TypeNode).Identifier.Name);
Assert.AreEqual("SomeDeeperClass", (path.Intermediates[1] as TypeNode).Identifier.Name);
}
}
public async Task When_MultiDependency_Edge()
{
using (var workspace = WorkspaceUtils.GetSubjectSolution())
{
var project = workspace.CurrentSolution.Projects.Single(p => p.Name == "SubjectSolution");
var graph = await NodeGraph.BuildGraph(CompilationCache.CacheWithSolution(workspace.CurrentSolution), ct : default);
var someClassNode = graph.Nodes[TypeNodeKey.GetFromFullName("SubjectSolution.SomeClass")];
var deepClassNode = graph.Nodes[TypeNodeKey.GetFromFullName("SubjectSolution.SomeClassDepth5")];
var roots = new HashSet <Node>();
roots.Add(someClassNode);
roots.Add(deepClassNode);
var paths = NodeGraphExtensions.GetMultiDependencyRootPaths(graph, roots).ToArray();
var path = paths.Single();
var displayGraph = graph.GetDisplaySubgraph(subgraphNodes: roots, pinnedNodes: SetUtils.GetEmpty <NodeKey>());
var multiEdges = displayGraph.Edges.OfType <MultiDependencyDisplayEdge>();
AssertEx.ContainsSingle(multiEdges, m => m.Source.DisplayString.EndsWith("SomeClass") && m.Target.DisplayString.EndsWith("SomeClassDepth5"));
}
}
public async Task When_Link_External_Assembly()
{
using (var workspace = WorkspaceUtils.GetSubjectSolution())
{
var graph = await NodeGraph.BuildGraph(CompilationCache.CacheWithSolution(workspace.CurrentSolution), ct : default);
var someClassKey = TypeNodeKey.GetFromFullName("SubjectSolution.SomeClass");
var someClassNode = graph.Nodes[someClassKey];
var someClassCoreKey = TypeNodeKey.GetFromFullName("SubjectSolution.Core.SomeClassCore");
var someClassCoreNode = graph.Nodes[someClassCoreKey];
var forwardLink = AssertEx.Contains(someClassNode.ForwardLinkNodes, n => n.Key.Equals(someClassCoreKey));
Assert.AreEqual(someClassCoreNode, forwardLink);
var backLink = AssertEx.Contains(someClassCoreNode.BackLinkNodes, n => n.Key.Equals(someClassKey));
Assert.AreEqual(someClassNode, backLink);
}
}
public async Task When_Updated_Reference_Added()
{
using var workspace = WorkspaceUtils.GetSubjectSolution();
var fullGraph = await NodeGraph.BuildGraph(CompilationCache.CacheWithSolution(workspace.CurrentSolution), ct : default);
var mutableClassKey = TypeNodeKey.GetFromFullName("SubjectSolution.Mutable.SomeMutableClass");
var mutableClassNode = (TypeNode)fullGraph.Nodes[mutableClassKey];
Assert.AreEqual(1, mutableClassNode.ForwardLinks.Count);
var project = workspace.CurrentSolution.Projects.Single(p => p.Name == "SubjectSolution");
var mutableDoc = project.Documents.Single(d => d.FilePath.EndsWith("SomeMutableClass.cs"));
var mutableRoot = await mutableDoc.GetSyntaxRootAsync();
var replaceableMethod = mutableRoot.DescendantNodes().OfType <MethodDeclarationSyntax>().Single(m => m.Identifier.Text == "MightBeReplaced");
var replacementText = @"
public void MightBeReplaced()
{
var replacement = new SomeClassAddableReference();
}
";
var mutableDocText = await mutableDoc.GetTextAsync();
var mutatedMutableDocText = mutableDocText.Replace(replaceableMethod.Span, replacementText);
var mutatedMutableDoc = mutableDoc.WithText(mutatedMutableDocText);
Assert.AreEqual(mutableDoc.Id, mutatedMutableDoc.Id);
var mutatedSolution = mutatedMutableDoc.Project.Solution;
await fullGraph.Update(CompilationCache.CacheWithSolution(mutatedSolution), new[] { mutableDoc.Id }, default);
var mutatedmutableClassNode = (TypeNode)fullGraph.Nodes[mutableClassKey]; // For now this is reference-equal to mutableClassNode, but let's try not to rely on it
Assert.AreEqual(2, mutableClassNode.ForwardLinks.Count);
AssertEx.Contains(mutableClassNode.ForwardLinkNodes, n => (n as TypeNode).Identifier.Name == "SomeClassAddableReference");
AssertConsistentState(fullGraph);
}