public void CentralTransitiveDependencyGroup_GetProperties()
        {
            // Arrange
            var nuGetFramework = NuGetFramework.Parse("NETStandard2.0");
            var libraryDep     = new LibraryDependency
            {
                LibraryRange = new LibraryRange(
                    "packageA",
                    VersionRange.Parse("1.0.0"),
                    LibraryDependencyTarget.Package)
            };
            var dependencies = new List <LibraryDependency>()
            {
                libraryDep
            };
            var centralTransitiveDependencyGroup = new CentralTransitiveDependencyGroup(nuGetFramework, dependencies);

            // Act
            var framework     = centralTransitiveDependencyGroup.FrameworkName;
            var tDependencies = centralTransitiveDependencyGroup.TransitiveDependencies;

            // Assert
            Assert.Equal(dependencies, tDependencies);
            Assert.Equal(nuGetFramework.ToString(), framework);
        }
예제 #2
0
        private void AddCentralTransitiveDependencyGroupsForPackageReference(PackageSpec project, LockFile lockFile, IEnumerable <RestoreTargetGraph> targetGraphs)
        {
            if (project.RestoreMetadata?.CentralPackageVersionsEnabled == false)
            {
                return;
            }

            // Do not pack anything from the runtime graphs
            // The runtime graphs are added in addition to the graphs without a runtime
            foreach (var targetGraph in targetGraphs.Where(targetGraph => string.IsNullOrEmpty(targetGraph.RuntimeIdentifier)))
            {
                var centralPackageVersionsForFramework = project.TargetFrameworks.Where(tfmi => tfmi.FrameworkName.Equals(targetGraph.Framework)).FirstOrDefault()?.CentralPackageVersions;

                // The transitive dependencies enforced by the central package version management file are written to the assets to be used by the pack task.
                IEnumerable <LibraryDependency> centralEnforcedTransitiveDependencies = targetGraph
                                                                                        .Flattened
                                                                                        .Where(graphItem => graphItem.IsCentralTransitive && centralPackageVersionsForFramework?.ContainsKey(graphItem.Key.Name) == true)
                                                                                        .Select((graphItem) =>
                {
                    CentralPackageVersion matchingCentralVersion = centralPackageVersionsForFramework[graphItem.Key.Name];
                    Dictionary <string, LibraryIncludeFlags> dependenciesIncludeFlags = _includeFlagGraphs[targetGraph];

                    var libraryDependency = new LibraryDependency()
                    {
                        LibraryRange            = new LibraryRange(matchingCentralVersion.Name, matchingCentralVersion.VersionRange, LibraryDependencyTarget.Package),
                        ReferenceType           = LibraryDependencyReferenceType.Transitive,
                        VersionCentrallyManaged = true,
                        IncludeType             = dependenciesIncludeFlags[matchingCentralVersion.Name]
                    };

                    return(libraryDependency);
                });

                if (centralEnforcedTransitiveDependencies.Any())
                {
                    var centralEnforcedTransitiveDependencyGroup = new CentralTransitiveDependencyGroup
                                                                   (
                        targetGraph.Framework,
                        centralEnforcedTransitiveDependencies
                                                                   );

                    lockFile.CentralTransitiveDependencyGroups.Add(centralEnforcedTransitiveDependencyGroup);
                }
            }
        }
        public void CentralTransitiveDependencyGroup_NotEqualObjects()
        {
            // Arrange
            var nuGetFramework1 = NuGetFramework.Parse("NETStandard2.0");
            var nuGetFramework2 = NuGetFramework.Parse("NETStandard3.0");
            var libraryDep1     = new LibraryDependency
            {
                LibraryRange = new LibraryRange(
                    "packageA",
                    VersionRange.Parse("1.0.0"),
                    LibraryDependencyTarget.Package)
            };
            var libraryDep2 = new LibraryDependency
            {
                LibraryRange = new LibraryRange(
                    "packageB",
                    VersionRange.Parse("1.0.0"),
                    LibraryDependencyTarget.Package)
            };
            var dependencies1 = new List <LibraryDependency>()
            {
                libraryDep1
            };
            var dependencies2 = new List <LibraryDependency>()
            {
                libraryDep2
            };

            var centralTransitiveDependencyGroup11 = new CentralTransitiveDependencyGroup(nuGetFramework1, dependencies1);
            var centralTransitiveDependencyGroup12 = new CentralTransitiveDependencyGroup(nuGetFramework1, dependencies2);
            var centralTransitiveDependencyGroup21 = new CentralTransitiveDependencyGroup(nuGetFramework2, dependencies1);
            var centralTransitiveDependencyGroup22 = new CentralTransitiveDependencyGroup(nuGetFramework2, dependencies2);

            // Act = Assert
            Assert.False(centralTransitiveDependencyGroup11.Equals(null));
            Assert.False(centralTransitiveDependencyGroup11.Equals(centralTransitiveDependencyGroup12));
            Assert.False(centralTransitiveDependencyGroup11.Equals(centralTransitiveDependencyGroup21));
            Assert.False(centralTransitiveDependencyGroup11.Equals(centralTransitiveDependencyGroup22));

            Assert.False(centralTransitiveDependencyGroup12.Equals(centralTransitiveDependencyGroup21));
            Assert.False(centralTransitiveDependencyGroup12.Equals(centralTransitiveDependencyGroup22));

            Assert.False(centralTransitiveDependencyGroup21.Equals(centralTransitiveDependencyGroup22));
        }
        public void Equals_WithOutOfOrderDependencies_ReturnsTrue()
        {
            // Arrange
            var leftSide = new CentralTransitiveDependencyGroup(
                NuGetFramework.Parse("net461"),
                new LibraryDependency[]
            {
                new LibraryDependency()
                {
                    LibraryRange = new LibraryRange()
                    {
                        Name = "first"
                    }
                },
                new LibraryDependency()
                {
                    LibraryRange = new LibraryRange()
                    {
                        Name = "second"
                    }
                }
            });
            var rightSide = new CentralTransitiveDependencyGroup(
                NuGetFramework.Parse("net461"),
                new LibraryDependency[]
            {
                new LibraryDependency()
                {
                    LibraryRange = new LibraryRange()
                    {
                        Name = "second"
                    }
                },
                new LibraryDependency()
                {
                    LibraryRange = new LibraryRange()
                    {
                        Name = "first"
                    }
                }
            });

            leftSide.Should().Be(rightSide);
        }
        public void CentralTransitiveDependencyGroup_EqualObjects()
        {
            // Arrange
            var nuGetFramework = NuGetFramework.Parse("NETStandard2.0");
            var libraryDep     = new LibraryDependency
            {
                LibraryRange = new LibraryRange(
                    "packageA",
                    VersionRange.Parse("1.0.0"),
                    LibraryDependencyTarget.Package)
            };
            var dependencies = new List <LibraryDependency>()
            {
                libraryDep
            };
            var centralTransitiveDependencyGroup1 = new CentralTransitiveDependencyGroup(nuGetFramework, dependencies);
            var centralTransitiveDependencyGroup2 = new CentralTransitiveDependencyGroup(nuGetFramework, dependencies);

            // Act = Assert
            Assert.True(centralTransitiveDependencyGroup1.Equals(centralTransitiveDependencyGroup1));
            Assert.True(centralTransitiveDependencyGroup1.Equals(centralTransitiveDependencyGroup2));
            Assert.Equal(centralTransitiveDependencyGroup1.GetHashCode(), centralTransitiveDependencyGroup2.GetHashCode());
        }
예제 #6
0
        public void LockFile_ConsiderCentralTransitiveDependencyGroupsForEquality()
        {
            // Arrange
            var dotNetFramework     = FrameworkConstants.CommonFrameworks.NetCoreApp10;
            var libraryDependency_1 = new LibraryDependency
            {
                LibraryRange = new LibraryRange(
                    "Microsoft.NETCore.App",
                    new VersionRange(
                        minVersion: new NuGetVersion("1.0.1"),
                        originalString: "1.0.1"),
                    LibraryDependencyTarget.Package)
            };
            var libraryDependency_2 = new LibraryDependency
            {
                LibraryRange = new LibraryRange(
                    "Microsoft.NETCore.App",
                    new VersionRange(
                        minVersion: new NuGetVersion("2.0.1"),
                        originalString: "2.0.1"),
                    LibraryDependencyTarget.Package)
            };
            var libraryDependency_3 = new LibraryDependency
            {
                LibraryRange = new LibraryRange(
                    "Microsoft.NETCore.App",
                    new VersionRange(
                        minVersion: new NuGetVersion("3.0.1"),
                        originalString: "3.0.1"),
                    LibraryDependencyTarget.Package)
            };
            var libraryDependency_11 = new LibraryDependency
            {
                LibraryRange = new LibraryRange(
                    "Microsoft.NETCore.App",
                    new VersionRange(
                        minVersion: new NuGetVersion("1.0.1"),
                        originalString: "1.0.1"),
                    LibraryDependencyTarget.Package)
            };
            var libraryDependency_22 = new LibraryDependency
            {
                LibraryRange = new LibraryRange(
                    "Microsoft.NETCore.App",
                    new VersionRange(
                        minVersion: new NuGetVersion("2.0.1"),
                        originalString: "2.0.1"),
                    LibraryDependencyTarget.Package)
            };
            var projCTDG_1_2 = new CentralTransitiveDependencyGroup(dotNetFramework, new List <LibraryDependency>()
            {
                libraryDependency_1, libraryDependency_2
            });
            var projCTDG_11_22 = new CentralTransitiveDependencyGroup(dotNetFramework, new List <LibraryDependency>()
            {
                libraryDependency_1, libraryDependency_2
            });

            var lockFile_1_2 = new LockFile
            {
                Version = 3,
                CentralTransitiveDependencyGroups = new List <CentralTransitiveDependencyGroup>()
                {
                    projCTDG_1_2
                }
            };
            var lockFile_11_22 = new LockFile
            {
                Version = 3,
                CentralTransitiveDependencyGroups = new List <CentralTransitiveDependencyGroup>()
                {
                    projCTDG_11_22
                }
            };
            var lockFile_1 = new LockFile
            {
                Version = 3,
                CentralTransitiveDependencyGroups = new List <CentralTransitiveDependencyGroup>()
                {
                    new CentralTransitiveDependencyGroup(dotNetFramework, new List <LibraryDependency>()
                    {
                        libraryDependency_1
                    })
                }
            };
            var lockFile_1_3 = new LockFile
            {
                Version = 3,
                CentralTransitiveDependencyGroups = new List <CentralTransitiveDependencyGroup>()
                {
                    new CentralTransitiveDependencyGroup(dotNetFramework, new List <LibraryDependency>()
                    {
                        libraryDependency_1, libraryDependency_3
                    })
                }
            };

            // Act & Assert
            Assert.Equal(lockFile_1_2, lockFile_1_2);
            Assert.Equal(lockFile_1_2, lockFile_11_22);
            Assert.NotEqual(lockFile_1_2, lockFile_1);
            Assert.NotEqual(lockFile_1_2, lockFile_1_3);
            Assert.Equal(lockFile_1_2.GetHashCode(), lockFile_11_22.GetHashCode());
        }