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