public void ProjectDependencyNode_Constructor(bool resolved)
{
// Arrange
var expectedIcon = resolved
? KnownMonikers.Application
: KnownMonikers.ReferenceWarning;
var priority = 3;
var id = DependencyNodeId.FromString(
"file:///[MyProviderType;c:\\MyItemSpec.dll;MyItemType;MyUniqueToken]");
var properties = new Dictionary <string, string>().ToImmutableDictionary();
// Act
var node = new ProjectDependencyNode(id,
ProjectTreeFlags.Empty,
priority,
properties,
resolved: resolved);
// Assert
Assert.Equal(expectedIcon, node.Icon);
Assert.Equal(resolved, node.Resolved);
Assert.Equal("MyItemSpec", node.Caption);
// Just to double-check that these properties are still set as sexpected
Assert.Equal(priority, node.Priority);
Assert.Equal(properties, node.Properties);
Assert.Equal(node.Icon, node.ExpandedIcon);
}
public AnalyzerDependencyNode(DependencyNodeId id,
ProjectTreeFlags flags,
int priority = 0,
IImmutableDictionary <string, string> properties = null,
bool resolved = true)
: base(id, flags, priority, properties, resolved)
{
Requires.NotNullOrEmpty(id.ItemSpec, nameof(id.ItemSpec));
if (resolved)
{
Icon = KnownMonikers.CodeInformation;
Caption = Path.GetFileNameWithoutExtension(id.ItemSpec);
}
else
{
Icon = KnownMonikers.ReferenceWarning;
// We show the full path that we couldn't resolve.
Caption = id.ItemSpec;
}
Priority = AnalyzerNodePriority;
ExpandedIcon = Icon;
Flags = (resolved ? GenericResolvedDependencyFlags : GenericUnresolvedDependencyFlags)
.Union(flags);
}
public void AnalyzerDependencyNode_Constructor_ResolvedUnresolved(
string itemSpec,
bool resolved,
string expectedCaption)
{
// Arrange
var priority = DependencyNode.AnalyzerNodePriority;
var id = DependencyNodeId.FromString(
$"file:///[AnalyzerDependency;{itemSpec};Analyzer;MyUniqueToken]");
var properties = new Dictionary <string, string>().ToImmutableDictionary();
// Act
var node = new AnalyzerDependencyNode(id,
ProjectTreeFlags.Empty,
priority,
properties,
resolved: resolved);
// Assert
Assert.Equal(resolved? KnownMonikers.CodeInformation : KnownMonikers.ReferenceWarning, node.Icon);
Assert.Equal(resolved, node.Resolved);
Assert.Equal(expectedCaption, node.Caption);
// Just to double-check that these properties are still set as sexpected
Assert.Equal(priority, node.Priority);
Assert.Equal(properties, node.Properties);
Assert.Equal(node.Icon, node.ExpandedIcon);
}
public void PackageUnknownDependencyNode_Constructor(bool resolved)
{
// Arrange
var defaultFlags = (resolved
? DependencyNode.ResolvedDependencyFlags
: DependencyNode.UnresolvedDependencyFlags)
.Add(ProjectTreeFlags.Common.ResolvedReference);
var caption = "MyCaption";
var id = DependencyNodeId.FromString(
"file:///[MyProviderType;c:\\MyItemSpec.dll;MyItemType;MyUniqueToken]");
var properties = new Dictionary <string, string>().ToImmutableDictionary();
var myFlags = ProjectTreeFlags.Create("MyFlag");
// Act
var node = new PackageUnknownDependencyNode(id,
caption,
myFlags,
properties,
resolved: resolved);
// Assert
Assert.Equal(KnownMonikers.QuestionMark, node.Icon);
Assert.Equal(resolved, node.Resolved);
Assert.Equal(caption, node.Caption);
Assert.Equal(properties, node.Properties);
Assert.Equal(node.Icon, node.ExpandedIcon);
Assert.True(node.Flags.Contains(defaultFlags.Union(myFlags)));
}
public void AssemblyDependencyNode_Constructor_Resolved(
string fusionName)
{
// Arrange
var priority = DependencyNode.FrameworkAssemblyNodePriority;
var id = DependencyNodeId.FromString(
"file:///[MyProviderType;c:\\MyItemSpec.dll;MyItemType;MyUniqueToken]");
var properties = new Dictionary <string, string>().ToImmutableDictionary();
// Act
var node = new AssemblyDependencyNode(id,
ProjectTreeFlags.Empty,
priority,
properties,
resolved: false,
fusionName: fusionName);
// Assert
Assert.Equal(KnownMonikers.ReferenceWarning, node.Icon);
Assert.Equal(false, node.Resolved);
Assert.Equal("MyItemSpec.dll", node.Caption);
// Just to double-check that these properties are still set as sexpected
Assert.Equal(priority, node.Priority);
Assert.Equal(properties, node.Properties);
Assert.Equal(node.Icon, node.ExpandedIcon);
}
public ProjectDependencyNode(DependencyNodeId id,
ProjectTreeFlags flags,
int priority = 0,
IImmutableDictionary <string, string> properties = null,
bool resolved = true)
: base(id, flags, priority, properties, resolved)
{
Requires.NotNullOrEmpty(id.ItemSpec, nameof(id.ItemSpec));
Caption = Path.GetFileNameWithoutExtension(id.ItemSpec);
if (resolved)
{
Icon = KnownMonikers.Application;
}
else
{
Icon = KnownMonikers.ReferenceWarning;
}
ExpandedIcon = Icon;
Flags = (resolved ? GenericResolvedDependencyFlags : GenericUnresolvedDependencyFlags)
.Union(flags);
}
private async Task <IProjectDependenciesSubTreeProvider> GetSubTreeProviderAsync(
IGraphContext graphContext,
GraphNode inputGraphNode,
string projectPath,
DependencyNodeId nodeId)
{
// Check if node has ProviderProperty set. It will be set for GraphNodes we created in
// this class, but root nodes at first would have it set to null so e ould have to use
// fallback File is part to get provider type for them.
var subTreeProvider = inputGraphNode?.GetValue <IProjectDependenciesSubTreeProvider>(
DependenciesGraphSchema.ProviderProperty);
if (subTreeProvider == null)
{
var projectContext = ProjectContextProvider.GetProjectContext(projectPath);
if (projectContext != null)
{
subTreeProvider = projectContext.GetProvider(nodeId.ProviderType);
}
}
if (subTreeProvider != null)
{
await RegisterSubTreeProviderAsync(subTreeProvider, graphContext).ConfigureAwait(false);
}
return(subTreeProvider);
}
public ComDependencyNode(DependencyNodeId id,
ProjectTreeFlags flags,
int priority = 0,
IImmutableDictionary <string, string> properties = null,
bool resolved = true)
: base(id, flags, priority, properties, resolved)
{
Requires.NotNullOrEmpty(id.ItemSpec, nameof(id.ItemSpec));
Caption = Path.GetFileNameWithoutExtension(id.ItemSpec);
if (resolved)
{
Icon = KnownMonikers.Component;
}
else
{
Icon = KnownMonikers.ReferenceWarning;
// We don't trim extension from here because usually there is no extension, and trimming it
// would make "System.Xml" look like "System".
Caption = Path.GetFileName(id.ItemSpec);
}
ExpandedIcon = Icon;
}
public void PackageFrameworkAssembliesDependencyNode_Constructor()
{
// Arrange
var defaultFlags = DependencyNode.DependencyFlags.Union(DependencyNode.PreFilledFolderNode);
var caption = "Framework Assemblies";
var id = DependencyNodeId.FromString(
"file:///[MyProviderType;c:\\MyItemSpec.dll;MyItemType;MyUniqueToken]");
var properties = new Dictionary <string, string>().ToImmutableDictionary();
var myFlags = ProjectTreeFlags.Create("MyFlag");
// Act
var node = new PackageFrameworkAssembliesDependencyNode(id,
myFlags,
properties,
resolved: true);
// Assert
Assert.Equal(KnownMonikers.Library, node.Icon);
Assert.Equal(true, node.Resolved);
Assert.Equal(caption, node.Caption);
Assert.Equal(properties, node.Properties);
Assert.Equal(node.Icon, node.ExpandedIcon);
Assert.True(node.Flags.Contains(defaultFlags.Union(myFlags)));
}
public SdkDependencyNode(DependencyNodeId id,
ProjectTreeFlags flags,
int priority = 0,
IImmutableDictionary <string, string> properties = null,
bool resolved = true)
: base(id, flags, priority, properties, resolved)
{
Requires.NotNullOrEmpty(id.ItemSpec, nameof(id.ItemSpec));
Caption = id.ItemSpec.Split(CommonConstants.CommaDelimiter, StringSplitOptions.RemoveEmptyEntries)
.FirstOrDefault();
if (resolved)
{
Icon = KnownMonikers.BrowserSDK;
}
else
{
Icon = KnownMonikers.ReferenceWarning;
}
Priority = SdkNodePriority;
ExpandedIcon = Icon;
Flags = (resolved ? GenericResolvedDependencyFlags : GenericUnresolvedDependencyFlags)
.Union(flags);
}
public void SharedProjectDependencyNode_Constructor(bool resolved)
{
// Arrange
var expectedIcon = resolved
? KnownMonikers.SharedProject
: KnownMonikers.ReferenceWarning;
var priority = 3;
var id = DependencyNodeId.FromString(
"file:///[MyProviderType;c:\\MyItemSpec.dll;MyItemType;MyUniqueToken]");
var properties = new Dictionary <string, string>().ToImmutableDictionary();
var defaultFlags = (resolved
? DependencyNode.GenericResolvedDependencyFlags
: DependencyNode.GenericUnresolvedDependencyFlags);
var myFlags = ProjectTreeFlags.Create("MyFlag");
// Act
var node = new SharedProjectDependencyNode(id,
myFlags,
priority,
properties,
resolved: resolved);
// Assert
Assert.Equal(expectedIcon, node.Icon);
Assert.Equal(resolved, node.Resolved);
Assert.Equal("MyItemSpec", node.Caption);
Assert.Equal("MyItemSpec", node.Name);
// Just to double-check that these properties are still set as sexpected
Assert.Equal(priority, node.Priority);
Assert.Equal(properties, node.Properties);
Assert.Equal(node.Icon, node.ExpandedIcon);
Assert.True(node.Flags.Contains(defaultFlags.Union(myFlags)));
}
public void AssemblyDependencyNode_Constructor_ResolvedUnresolved(
string fusionName,
string expectedCaption)
{
// Arrange
var priority = DependencyNode.FrameworkAssemblyNodePriority;
var id = DependencyNodeId.FromString(
"file:///[MyProviderType;c:\\MyItemSpec.dll;MyItemType;MyUniqueToken]");
var properties = new Dictionary <string, string>().ToImmutableDictionary();
var defaultFlags = DependencyNode.GenericResolvedDependencyFlags;
var myFlags = ProjectTreeFlags.Create("MyFlag");
// Act
var node = new AssemblyDependencyNode(id,
myFlags,
priority,
properties,
resolved: true,
fusionName: fusionName);
// Assert
Assert.Equal(KnownMonikers.Reference, node.Icon);
Assert.Equal(true, node.Resolved);
Assert.Equal(expectedCaption, node.Caption);
Assert.Equal(expectedCaption, node.Name);
// Just to double-check that these properties are still set as sexpected
Assert.Equal(priority, node.Priority);
Assert.Equal(properties, node.Properties);
Assert.Equal(node.Icon, node.ExpandedIcon);
Assert.True(node.Flags.Contains(defaultFlags.Union(myFlags)));
}
private GraphNode GetNodeById(string projectPath, IEnumerable <GraphNode> nodes, DependencyNodeId id)
{
var projectFolder = Path.GetDirectoryName(projectPath);
foreach (var node in nodes)
{
var value = node.Id.GetNestedValueByName <Uri>(CodeGraphNodeIdName.File);
// for idPartName == CodeGraphNodeIdName.File it can be null, avoid unnecessary exception
if (value == null)
{
continue;
}
var idString = (value.IsAbsoluteUri ? value.LocalPath : value.ToString()).Trim('/');
var nodeId = DependencyNodeId.FromString(idString);
if (nodeId != null && nodeId.Equals(id))
{
return(node);
}
else
{
var topLevelId = Path.Combine(projectFolder, id.ItemSpec).Replace('/', '\\');
if (topLevelId.Equals(idString, StringComparison.OrdinalIgnoreCase))
{
return(node);
}
}
}
return(null);
}
private IDependencyNode CreateDependencyNode(DependencyMetadata dependencyMetadata,
DependencyNodeId id = null,
bool topLevel = true)
{
if (id == null)
{
var uniqueToken = topLevel ? null : Guid.NewGuid().ToString();
id = new DependencyNodeId(ProviderType,
dependencyMetadata.ItemSpec,
ResolvedPackageReference.PrimaryDataSourceItemType,
uniqueToken);
}
// here based on DependencyType we create a corresponding node
IDependencyNode dependencyNode = null;
switch (dependencyMetadata.DependencyType)
{
case DependencyType.Package:
dependencyNode = new PackageDependencyNode(
id,
name: dependencyMetadata.Name,
caption: dependencyMetadata.FriendlyName,
flags: NuGetSubTreeNodeFlags,
properties: dependencyMetadata.Properties,
resolved: dependencyMetadata.Resolved);
break;
case DependencyType.Assembly:
case DependencyType.FrameworkAssembly:
dependencyNode = new PackageAssemblyDependencyNode(
id,
caption: dependencyMetadata.Name,
flags: NuGetSubTreeNodeFlags,
properties: dependencyMetadata.Properties,
resolved: dependencyMetadata.Resolved);
break;
case DependencyType.AnalyzerAssembly:
dependencyNode = new PackageAnalyzerAssemblyDependencyNode(
id,
caption: dependencyMetadata.Name,
flags: NuGetSubTreeNodeFlags,
properties: dependencyMetadata.Properties,
resolved: dependencyMetadata.Resolved);
break;
default:
dependencyNode = new PackageUnknownDependencyNode(
id,
caption: dependencyMetadata.Name,
flags: NuGetSubTreeNodeFlags,
properties: dependencyMetadata.Properties,
resolved: dependencyMetadata.Resolved);
break;
}
return(dependencyNode);
}
public void ProjectDependencyNode_Constructor_WhenItemSpecIsNullOrEmpty_ShouldThrow()
{
var id = DependencyNodeId.FromString("file:///[MyProviderType]");
Assert.Throws <ArgumentException>("ItemSpec", () => {
new ProjectDependencyNode(id, ProjectTreeFlags.Empty);
});
}
public virtual IDependencyNode GetDependencyNode(DependencyNodeId nodeId)
{
Requires.NotNull(nodeId, nameof(nodeId));
var rootNodeChildren = RootNode.Children;
return(rootNodeChildren.FirstOrDefault(x => x.Id.Equals(nodeId)));
}
public void PackageDependencyNode_Constructor_WhenCaptionIsNullOrEmpty_ShouldThrow()
{
var id = DependencyNodeId.FromString("file:///[MyProviderType]");
Assert.Throws <ArgumentNullException>("caption", () => {
new PackageDependencyNode(id, null, ProjectTreeFlags.Empty);
});
}
public void DependencyNodeId_GetHashCode(string firstIdString,
string secondIdString,
bool expectedResult)
{
var id1 = DependencyNodeId.FromString(firstIdString);
var id2 = DependencyNodeId.FromString(secondIdString);
Assert.Equal(id1.GetHashCode(), id2.GetHashCode());
}
public void DependencyNodeId_Equals(string firstIdString,
string secondIdString,
bool expectedResult)
{
var id1 = DependencyNodeId.FromString(firstIdString);
var id2 = DependencyNodeId.FromString(secondIdString);
Assert.Equal(expectedResult, id1.Equals(id2));
Assert.Equal(expectedResult, id2.Equals(id1));
}
public void DependencyNodeId_ToString(string providerType,
string itemSpec,
string itemType,
string uniqueToken,
string expectedResult)
{
var id = new DependencyNodeId(providerType, itemSpec, itemType, uniqueToken);
Assert.Equal(expectedResult, id.ToString());
}
public void DependencyNodeId_Constructor()
{
Assert.Throws <ArgumentNullException>("providerType", () => {
var id = new DependencyNodeId(null, null, null, null);
});
Assert.Throws <ArgumentException>("providerType", () => {
var id = new DependencyNodeId("", null, null, null);
});
}
private IDependencyNode CreateFrameworkAssembliesFolder()
{
var id = new DependencyNodeId(ProviderType,
"FrameworkAssemblies",
ResolvedPackageReference.PrimaryDataSourceItemType,
Guid.NewGuid().ToString());
return(new PackageFrameworkAssembliesDependencyNode(
id,
flags: NuGetSubTreeNodeFlags));
}
/// <summary>
/// Create a project dependency node given ID
/// </summary>
private IDependencyNode CreateDependencyNode(DependencyNodeId id,
int priority,
IImmutableDictionary <string, string> properties,
bool resolved)
{
return(new ProjectDependencyNode(id,
flags: ProjectSubTreeNodeFlags,
priority: priority,
properties: properties,
resolved: resolved));
}
/// <summary>
/// Checks if given node has children and adds corresponding IDependencyDescription to the node.
/// </summary>
private async Task CheckChildrenAsync(IGraphContext graphContext)
{
foreach (var inputGraphNode in graphContext.InputNodes)
{
if (graphContext.CancelToken.IsCancellationRequested)
{
return;
}
// All graph nodes generated here will have this unique node id, root node will have it equal to null
var nodeIdString = GetPartialValueFromGraphNodeId(inputGraphNode.Id, CodeGraphNodeIdName.File);
var nodeId = DependencyNodeId.FromString(nodeIdString);
if (nodeId == null)
{
continue;
}
var projectPath = GetPartialValueFromGraphNodeId(inputGraphNode.Id, CodeGraphNodeIdName.Assembly);
if (string.IsNullOrEmpty(projectPath))
{
continue;
}
var subTreeProvider = await GetSubTreeProviderAsync(graphContext,
inputGraphNode,
projectPath,
nodeId).ConfigureAwait(false);
if (subTreeProvider == null)
{
continue;
}
IDependencyNode nodeInfo = subTreeProvider.GetDependencyNode(nodeId);
if (nodeInfo == null)
{
continue;
}
using (var scope = new GraphTransactionScope())
{
inputGraphNode.SetValue(DependenciesGraphSchema.ProviderProperty, subTreeProvider);
inputGraphNode.SetValue(DependenciesGraphSchema.DependencyNodeProperty, nodeInfo);
if (nodeInfo.HasChildren)
{
inputGraphNode.SetValue(DgmlNodeProperties.ContainsChildren, true);
}
scope.Complete();
}
}
}
public override IDependencyNode GetDependencyNode(DependencyNodeId id)
{
lock (_snapshotLock)
{
IDependencyNode node = null;
if (CurrentSnapshot.NodesCache.TryGetValue(id, out node))
{
return(node);
}
DependencyMetadata dependencyMetadata = null;
if (!CurrentSnapshot.DependenciesWorld.TryGetValue(id.ItemSpec, out dependencyMetadata))
{
return(null);
}
// create node and it's direct children
node = CreateDependencyNode(dependencyMetadata, id);
CurrentSnapshot.NodesCache.Add(id, node);
var frameworkAssemblies = new List <DependencyMetadata>();
foreach (var childItemSpec in dependencyMetadata.DependenciesItemSpecs)
{
DependencyMetadata childDependencyMetadata = null;
if (!CurrentSnapshot.DependenciesWorld.TryGetValue(childItemSpec, out childDependencyMetadata))
{
continue;
}
if (childDependencyMetadata.DependencyType == DependencyType.FrameworkAssembly)
{
frameworkAssemblies.Add(childDependencyMetadata);
continue;
}
node.AddChild(CreateDependencyNode(childDependencyMetadata, topLevel: false));
}
if (frameworkAssemblies.Count > 0)
{
var frameworkAssembliesNode = CreateFrameworkAssembliesFolder();
node.AddChild(frameworkAssembliesNode);
foreach (var fxAssemblyMetadata in frameworkAssemblies)
{
frameworkAssembliesNode.AddChild(CreateDependencyNode(fxAssemblyMetadata, topLevel: false));
}
}
return(node);
}
}
public void DependencyNode_Alias(string idString, string caption, string expectedAlias)
{
// Arrange
var id = DependencyNodeId.FromString(idString);
// Act
var node = new DependencyNode(id, ProjectTreeFlags.Empty);
node.Caption = caption;
// Assert
Assert.Equal(expectedAlias, node.Alias);
}
/// <summary>
/// Returns refreshed dependnecy node. There is a non trivial logic which is important:
/// in order to find node at anypoint of time, we always fill live node instance children collection,
/// which then could be found by recusrive search from RootNode. However we return always a new
/// instance for requested node, to allow graph provider to compare old node instances to new ones
/// when some thing changes in the dependent project and track changes. So in
/// DependenciesGrpahProvider.TrackChangesOnGraphContextAsync we always remember old children
/// collection for existing node, since for top level nodes (sent by CPS IProjectTree(s) we do update
/// them here, which would make no difference between old and new nodes. For lower hierarchies below top
/// nodes, new instances solve this problem.
/// </summary>
/// <param name="nodeId"></param>
/// <returns></returns>
public override IDependencyNode GetDependencyNode(DependencyNodeId nodeId)
{
if (nodeId == null)
{
return(null);
}
// normalize id to have regular paths (graph provider replaces \ with /.
nodeId = nodeId.ToNormalizedId();
var node = RootNode.FindNode(nodeId, recursive: true);
if (node == null)
{
return(null);
}
if (string.IsNullOrEmpty(nodeId.ContextProject))
{
return(node);
}
var projectPath = nodeId.ContextProject;
var projectContext = ProjectContextProvider.GetProjectContext(projectPath);
if (projectContext == null)
{
return(node);
}
node.RemoveAllChildren();
foreach (var subTreeProvider in projectContext.GetProviders())
{
if (subTreeProvider.RootNode == null || !subTreeProvider.RootNode.HasChildren)
{
continue;
}
var rootNodeChildren = subTreeProvider.RootNode.Children;
foreach (var child in rootNodeChildren)
{
node.AddChild(DependencyNode.Clone(child));
}
}
// create a new instance of the node to allow graph provider to compare changes
var newNode = CreateDependencyNode(node.Id, node.Priority, node.Properties, node.Resolved);
newNode.AddChildren(node.Children);
return(newNode);
}
public void DependencyNode_Constructor_Caption(string idString, string expectedCaption)
{
// Arrange
var id = DependencyNodeId.FromString(idString);
var properties = new Dictionary <string, string>().ToImmutableDictionary();
var priority = 2;
// Act
var node = new DependencyNode(id, ProjectTreeFlags.Empty, priority, properties);
// Assert
Assert.Equal(expectedCaption, node.Caption);
Assert.Equal(priority, node.Priority);
Assert.Equal(properties, node.Properties);
}
protected override IDependencyNode CreateDependencyNode(string itemSpec,
string itemType,
int priority = 0,
IImmutableDictionary <string, string> properties = null,
bool resolved = true)
{
var id = new DependencyNodeId(ProviderType,
itemSpec,
itemType ?? ResolvedProjectReference.PrimaryDataSourceItemType);
return(new ProjectDependencyNode(id,
flags: ProjectSubTreeNodeFlags,
priority: priority,
properties: properties,
resolved: resolved));
}
public void DependencyNode_Equals(string firstIdString,
string secondIdString,
bool expectedResult)
{
// Arrange
var id1 = DependencyNodeId.FromString(firstIdString);
var id2 = DependencyNodeId.FromString(secondIdString);
// Act
var node1 = new DependencyNode(id1, ProjectTreeFlags.Empty);
var node2 = new DependencyNode(id2, ProjectTreeFlags.Empty);
// Assert
Assert.Equal(expectedResult, node1.Equals(node2));
Assert.Equal(expectedResult, node2.Equals(node1));
}
