public void Implicit() { var properties = ImmutableStringDictionary <string> .EmptyOrdinal.Add("myProp", "myVal"); var dependencyIDs = new[] { "id1", "id2" }; var model = new PackageDependencyModel( path: "c:\\myPath", originalItemSpec: "myOriginalItemSpec", name: "myPath", version: "", isResolved: true, isImplicit: true, properties: properties, isTopLevel: true, isVisible: true, dependenciesIDs: dependencyIDs); Assert.Equal(PackageRuleHandler.ProviderTypeString, model.ProviderType); Assert.Equal("c:\\myPath", model.Path); Assert.Equal("myPath", model.Name); Assert.Equal("myOriginalItemSpec", model.OriginalItemSpec); Assert.Equal("myOriginalItemSpec", model.Id); Assert.Equal("", model.Version); Assert.Equal("myPath", model.Caption); Assert.Equal(ResolvedPackageReference.SchemaName, model.SchemaName); Assert.Equal(PackageReference.PrimaryDataSourceItemType, model.SchemaItemType); Assert.True(model.TopLevel); Assert.True(model.Visible); Assert.True(model.Resolved); Assert.True(model.Implicit); Assert.Equal(properties, model.Properties); Assert.Equal(Dependency.PackageNodePriority, model.Priority); Assert.Equal(ManagedImageMonikers.NuGetGreyPrivate, model.Icon); Assert.Equal(ManagedImageMonikers.NuGetGreyPrivate, model.ExpandedIcon); Assert.Equal(ManagedImageMonikers.NuGetGreyWarning, model.UnresolvedIcon); Assert.Equal(ManagedImageMonikers.NuGetGreyWarning, model.UnresolvedExpandedIcon); AssertEx.CollectionLength(model.DependencyIDs, 2); Assert.Equal( DependencyTreeFlags.NuGetSubTreeNodeFlags + DependencyTreeFlags.PackageNodeFlags + DependencyTreeFlags.SupportsHierarchy + DependencyTreeFlags.GenericResolvedDependencyFlags - DependencyTreeFlags.SupportsRemove, model.Flags); }
public void Unresolved() { var properties = ImmutableDictionary <string, string> .Empty.Add("myProp", "myVal"); var dependencyIDs = new[] { "id1", "id2" }; var flag = ProjectTreeFlags.Create("MyCustomFlag"); var model = new PackageDependencyModel( providerType: "myProvider", path: "c:\\myPath", originalItemSpec: "myOriginalItemSpec", name: "myPath", flags: flag, version: "myVersion", resolved: false, isImplicit: false, properties: properties, isTopLevel: true, isVisible: true, dependenciesIDs: dependencyIDs); Assert.Equal("myProvider", model.ProviderType); Assert.Equal("c:\\myPath", model.Path); Assert.Equal("myPath", model.Name); Assert.Equal("myOriginalItemSpec", model.OriginalItemSpec); Assert.Equal("myOriginalItemSpec", model.Id); Assert.Equal("myVersion", model.Version); Assert.Equal("myPath (myVersion)", model.Caption); Assert.Equal(PackageReference.SchemaName, model.SchemaName); Assert.Equal(PackageReference.PrimaryDataSourceItemType, model.SchemaItemType); Assert.True(model.TopLevel); Assert.True(model.Visible); Assert.False(model.Resolved); Assert.False(model.Implicit); Assert.Equal(properties, model.Properties); Assert.Equal(Dependency.UnresolvedReferenceNodePriority, model.Priority); Assert.Equal(ManagedImageMonikers.NuGetGrey, model.Icon); Assert.Equal(ManagedImageMonikers.NuGetGrey, model.ExpandedIcon); Assert.Equal(ManagedImageMonikers.NuGetGreyWarning, model.UnresolvedIcon); Assert.Equal(ManagedImageMonikers.NuGetGreyWarning, model.UnresolvedExpandedIcon); AssertEx.CollectionLength(model.DependencyIDs, 2); Assert.True(model.Flags.Contains(DependencyTreeFlags.PackageNodeFlags)); Assert.True(model.Flags.Contains(DependencyTreeFlags.SupportsHierarchy)); Assert.True(model.Flags.Contains(flag)); }
private bool TryCreatePackageDependencyModel( string itemSpec, bool isResolved, IImmutableDictionary <string, string> properties, Func <string, bool>?isEvaluatedItemSpec, ITargetFramework targetFramework, [NotNullWhen(returnValue: true)] out PackageDependencyModel?dependencyModel) { Requires.NotNullOrEmpty(itemSpec, nameof(itemSpec)); Requires.NotNull(properties, nameof(properties)); bool isImplicitlyDefined = properties.GetBoolProperty(ProjectItemMetadata.IsImplicitlyDefined) ?? false; if (isResolved) { // We have design-time build data Requires.NotNull(targetFramework, nameof(targetFramework)); Requires.NotNull(isEvaluatedItemSpec !, nameof(isEvaluatedItemSpec)); string?name = properties.GetStringProperty(ProjectItemMetadata.Name); string?dependencyType = properties.GetStringProperty(ProjectItemMetadata.Type); if (dependencyType != null) { // LEGACY MODE // // In 16.7 (SDK 3.1.4xx) the format of ResolvedPackageReference items was changed in task PreprocessPackageDependenciesDesignTime. // // If we observe "Type" metadata then we are running with an older SDK and need to preserve some // legacy behaviour to avoid breaking the dependencies node too much. Transitive dependencies will // not be displayed, but we should be able to provide an equivalent experience for top-level items. if (!StringComparers.PropertyLiteralValues.Equals(dependencyType, "Package")) { // Legacy behaviour included items of various types. We now only accept "Package". dependencyModel = null; return(false); } // Legacy behaviour was to return packages for all targets, even though we have a build per-target. // The package's target was prefixed to its ItemSpec (for example: ".NETFramework,Version=v4.8/MetadataExtractor/2.3.0"). // We would then filter out items for the wrong target here. // // From 16.7 we no longer return items from other target frameworks during DTB, and we remove the target prefix from ItemSpec. // // This code preserves filtering logic when processing legacy items. int slashIndex = itemSpec.IndexOf('/'); if (slashIndex != -1) { string targetFrameworkName = s_targetFrameworkInternPool.Intern(itemSpec.Substring(0, slashIndex)); if (_targetFrameworkProvider.GetTargetFramework(targetFrameworkName)?.Equals(targetFramework) != true) { // Item is not for the correct target dependencyModel = null; return(false); } } // Name metadata is required in 16.7. Legacy behaviour uses ItemSpec as a fallback. name ??= itemSpec; } else { if (Strings.IsNullOrEmpty(name)) { // This should not happen as Name is required in PreprocessPackageDependenciesDesignTime from 16.7 dependencyModel = null; return(false); } } bool isTopLevel = isImplicitlyDefined || isEvaluatedItemSpec(name); if (!isTopLevel) { // We no longer accept non-top-level dependencies from DTB data. See note above about legacy mode support. dependencyModel = null; return(false); } dependencyModel = new PackageDependencyModel( originalItemSpec: name, version: properties.GetStringProperty(ProjectItemMetadata.Version) ?? string.Empty, isResolved: true, isImplicitlyDefined, isVisible: !isImplicitlyDefined, properties); } else { // We only have evaluation data System.Diagnostics.Debug.Assert(itemSpec.IndexOf('/') == -1); dependencyModel = new PackageDependencyModel( originalItemSpec: itemSpec, version: properties.GetStringProperty(ProjectItemMetadata.Version) ?? string.Empty, isResolved: false, isImplicitlyDefined, isVisible: !isImplicitlyDefined, properties); } return(true); }
private IDependencyModel GetDependencyModel( string itemSpec, bool resolved, IImmutableDictionary <string, string> properties, IProjectChangeDescription projectChange, HashSet <string> unresolvedChanges, ITargetFramework targetFramework) { PackageDependencyMetadata metadata; bool isTopLevel = true; bool isTarget = false; if (resolved) { metadata = new PackageDependencyMetadata(itemSpec, properties); isTopLevel = metadata.IsImplicitlyDefined || (metadata.DependencyType == DependencyType.Package && unresolvedChanges != null && unresolvedChanges.Contains(metadata.Name)); isTarget = metadata.IsTarget; ITargetFramework packageTargetFramework = TargetFrameworkProvider.GetTargetFramework(metadata.Target); if (!(packageTargetFramework?.Equals(targetFramework) == true)) { return(null); } } else { metadata = CreateUnresolvedMetadata(itemSpec, properties); } if (isTarget) { return(null); } string originalItemSpec = itemSpec; if (resolved && isTopLevel) { originalItemSpec = metadata.Name; } IDependencyModel dependencyModel = null; switch (metadata.DependencyType) { case DependencyType.Package: dependencyModel = new PackageDependencyModel( ProviderType, itemSpec, originalItemSpec, metadata.Name, DependencyTreeFlags.NuGetSubTreeNodeFlags, metadata.Version, resolved, metadata.IsImplicitlyDefined, isTopLevel, !metadata.IsImplicitlyDefined /*visible*/, properties, metadata.DependenciesItemSpecs); break; case DependencyType.Assembly: case DependencyType.FrameworkAssembly: dependencyModel = new PackageAssemblyDependencyModel( ProviderType, itemSpec, originalItemSpec, metadata.Name, DependencyTreeFlags.NuGetSubTreeNodeFlags, resolved, properties, metadata.DependenciesItemSpecs); break; case DependencyType.AnalyzerAssembly: dependencyModel = new PackageAnalyzerAssemblyDependencyModel( ProviderType, itemSpec, originalItemSpec, metadata.Name, DependencyTreeFlags.NuGetSubTreeNodeFlags, resolved, properties, metadata.DependenciesItemSpecs); break; case DependencyType.Diagnostic: dependencyModel = new DiagnosticDependencyModel( ProviderType, itemSpec, metadata.Severity, metadata.DiagnosticCode, metadata.Name, DependencyTreeFlags.NuGetSubTreeNodeFlags, isVisible: true, properties: properties); break; default: dependencyModel = new PackageUnknownDependencyModel( ProviderType, itemSpec, originalItemSpec, metadata.Name, DependencyTreeFlags.NuGetSubTreeNodeFlags, resolved, properties, metadata.DependenciesItemSpecs); break; } return(dependencyModel); }