private static TargetFrameworkInformation CreateTargetFrameworkInformation()
{
NuGetFramework nugetFramework = new NuGetFramework("net40");
var dependencyFoo = new LibraryDependency(new LibraryRange("foo", null, LibraryDependencyTarget.All),
LibraryDependencyType.Default,
LibraryIncludeFlags.All,
LibraryIncludeFlags.All,
new List <Common.NuGetLogCode>(),
autoReferenced: false,
generatePathProperty: true);
var centralVersionFoo = new CentralPackageVersion("foo", VersionRange.Parse("1.0.0"));
var centralVersionBar = new CentralPackageVersion("bar", VersionRange.Parse("2.0.0"));
var dependencies = new List <LibraryDependency>()
{
dependencyFoo
};
var assetTargetFallback = true;
var warn = false;
TargetFrameworkInformation tfi = new TargetFrameworkInformation()
{
AssetTargetFallback = assetTargetFallback,
Dependencies = dependencies,
Warn = warn,
FrameworkName = nugetFramework,
};
tfi.CentralPackageVersions.Add(centralVersionFoo.Name, centralVersionFoo);
tfi.CentralPackageVersions.Add(centralVersionBar.Name, centralVersionBar);
return(tfi);
}
public void IsLockFileStillValid_TransitiveVersionsMovedToCentralFile_InvalidateLockFile()
{
// Arrange
var framework = CommonFrameworks.NetStandard20;
var projectName = "project";
var cpvm1 = new CentralPackageVersion("cpvm1", VersionRange.Parse("1.0.0"));
var cpvm2 = new CentralPackageVersion("cpvm2", VersionRange.Parse("1.0.0"));
var dependency1 = new LibraryDependency(
new LibraryRange("cpvm1", versionRange: null, LibraryDependencyTarget.Package),
LibraryDependencyType.Default,
LibraryIncludeFlags.All,
LibraryIncludeFlags.All,
new List <Common.NuGetLogCode>(),
autoReferenced: false,
generatePathProperty: true,
versionCentrallyManaged: false,
LibraryDependencyReferenceType.Direct,
aliases: "stuff");
var tfm = new TargetFrameworkInformation();
tfm.FrameworkName = framework;
tfm.CentralPackageVersions.Add("cpvm1", cpvm1);
tfm.CentralPackageVersions.Add("cpvm2", cpvm2);
tfm.Dependencies.Add(dependency1);
LibraryDependency.ApplyCentralVersionInformation(tfm.Dependencies, tfm.CentralPackageVersions);
var project = new PackageSpec(new List <TargetFrameworkInformation>()
{
tfm
});
project.RestoreMetadata = new ProjectRestoreMetadata()
{
ProjectUniqueName = projectName, CentralPackageVersionsEnabled = true
};
DependencyGraphSpec dgSpec = new DependencyGraphSpec();
dgSpec.AddRestore(projectName);
dgSpec.AddProject(project);
var lockFile = new PackagesLockFileBuilder()
.WithTarget(target => target
.WithFramework(CommonFrameworks.NetStandard20)
.WithDependency(dep => dep
.WithId("cpvm1")
.WithRequestedVersion(VersionRange.Parse("1.0.0"))
.WithType(PackageDependencyType.Direct))
.WithDependency(dep => dep
.WithId("cpvm2")
.WithRequestedVersion(VersionRange.Parse("1.0.0"))
.WithType(PackageDependencyType.Transitive)))
.Build();
// The central package version cpvm2 has was changed from transitive to central
var actual = PackagesLockFileUtilities.IsLockFileStillValid(dgSpec, lockFile);
Assert.False(actual);
}
public void DistinctListOfObjects()
{
// Arrange
var name1 = "name1";
var name2 = "name2";
var nameU1 = "Name1";
var versionRange1 = VersionRange.Parse("1.0.0");
var versionRange2 = VersionRange.Parse("2.0.0");
var versionRange3 = VersionRange.Parse("3.0.0");
var cpv11 = new CentralPackageVersion(name1, versionRange1);
var cpv12 = new CentralPackageVersion(name1, versionRange2);
var cpvU13 = new CentralPackageVersion(nameU1, versionRange3);
var cpv21 = new CentralPackageVersion(name2, versionRange1);
var cpvs = new List <CentralPackageVersion>()
{
cpv11, cpv12, cpvU13, cpv21
};
// Act
var distinctElements = cpvs.Distinct(CentralPackageVersionNameComparer.Default).ToList();
// Assert
// There should be only two elements distinct as the comparer is name comparer with StringComparison OrdinalIgnoreCase
Assert.Equal(2, distinctElements.Count);
Assert.Equal(name1, distinctElements[0].Name);
Assert.Equal(name2, distinctElements[1].Name);
}
public void GetSpecDependencies_AddsCentralPackageVersionsIfDefined(bool cpvmEnabled)
{
// Arrange
var logger = new TestLogger();
var dependencyFoo = new LibraryDependency(
libraryRange: new LibraryRange("foo", versionRange: null, LibraryDependencyTarget.Package),
type: LibraryDependencyType.Default,
includeType: LibraryIncludeFlags.All,
suppressParent: LibraryIncludeFlags.None,
noWarn: new List <Common.NuGetLogCode>(),
autoReferenced: false,
generatePathProperty: true,
versionCentrallyManaged: false,
LibraryDependencyReferenceType.Direct,
aliases: "stuff");
var centralVersionFoo = new CentralPackageVersion("foo", VersionRange.Parse("2.0.0"));
var centralVersionBar = new CentralPackageVersion("bar", VersionRange.Parse("2.0.0"));
var tfi = CreateTargetFrameworkInformation(new List <LibraryDependency>()
{
dependencyFoo
}, new List <CentralPackageVersion>()
{
centralVersionFoo, centralVersionBar
}, cpvmEnabled);
var dependencyGraphSpec = CreateDependencyGraphSpecWithCentralDependencies(cpvmEnabled, tfi);
var packSpec = dependencyGraphSpec.Projects[0];
// Act
var dependencies = PackageSpecReferenceDependencyProvider.GetSpecDependencies(packSpec, tfi.FrameworkName);
// Assert
if (cpvmEnabled)
{
Assert.Equal(2, dependencies.Count);
var barDep = dependencies.Where(d => d.Name == "bar").First();
Assert.NotNull(barDep);
Assert.True(barDep.VersionCentrallyManaged);
Assert.False(barDep.AutoReferenced);
Assert.Equal(LibraryDependencyReferenceType.None, barDep.ReferenceType);
Assert.Equal("[2.0.0, )", barDep.LibraryRange.VersionRange.ToNormalizedString());
var fooDep = dependencies.Where(d => d.Name == "foo").First();
Assert.NotNull(fooDep);
Assert.False(fooDep.AutoReferenced);
Assert.True(fooDep.VersionCentrallyManaged);
Assert.Equal(LibraryDependencyReferenceType.Direct, fooDep.ReferenceType);
Assert.Equal("[2.0.0, )", fooDep.LibraryRange.VersionRange.ToNormalizedString());
}
else
{
Assert.Equal(1, dependencies.Count);
var fooDep = dependencies.Where(d => d.Name == "foo").First();
Assert.NotNull(fooDep);
Assert.False(fooDep.VersionCentrallyManaged);
Assert.Null(fooDep.LibraryRange.VersionRange);
Assert.Equal(LibraryDependencyReferenceType.Direct, fooDep.ReferenceType);
}
}
public void IsDependencyValidForGraphTest(LibraryDependencyReferenceType referenceType, bool versionCentrallyManaged)
{
var centralPackageName = "D";
var context = new TestRemoteWalkContext();
var centralPackageVersion = new CentralPackageVersion(centralPackageName, VersionRange.Parse("2.0.0"));
var centralPackageVersionDependecy_VersionCentrallyManaged = new LibraryDependency()
{
LibraryRange = new LibraryRange(centralPackageVersion.Name, centralPackageVersion.VersionRange, LibraryDependencyTarget.Package),
VersionCentrallyManaged = versionCentrallyManaged,
ReferenceType = referenceType,
};
var walker = new RemoteDependencyWalker(context);
// Act
var expectedResult = walker.IsDependencyValidForGraph(centralPackageVersionDependecy_VersionCentrallyManaged);
// Assert
if (referenceType != LibraryDependencyReferenceType.None)
{
Assert.True(expectedResult);
}
else
{
Assert.False(expectedResult);
}
}
private static CentralPackageVersion ToCentralPackageVersion(IVsReferenceItem item)
{
string id = item.Name;
VersionRange versionRange = GetVersionRange(item);
var centralPackageVersion = new CentralPackageVersion(id, versionRange);
return(centralPackageVersion);
}
public void AddProject_WhenDependencyVersionIsNull_CentralPackageVersionAppliesOnlyWhenAutoReferencedIsFalse()
{
// Arrange
var dependencyFoo = new LibraryDependency(
new LibraryRange("foo", versionRange: null, LibraryDependencyTarget.Package),
LibraryDependencyType.Default,
LibraryIncludeFlags.All,
LibraryIncludeFlags.All,
new List <Common.NuGetLogCode>(),
autoReferenced: false,
generatePathProperty: true);
var dependencyBar = new LibraryDependency(
new LibraryRange("bar", VersionRange.Parse("3.0.0"), LibraryDependencyTarget.Package),
LibraryDependencyType.Default,
LibraryIncludeFlags.All,
LibraryIncludeFlags.All,
new List <Common.NuGetLogCode>(),
autoReferenced: true,
generatePathProperty: true);
var dependencyBoom = new LibraryDependency(
new LibraryRange("boom", versionRange: null, LibraryDependencyTarget.Package),
LibraryDependencyType.Default,
LibraryIncludeFlags.All,
LibraryIncludeFlags.All,
new List <Common.NuGetLogCode>(),
autoReferenced: true,
generatePathProperty: true);
var centralVersionFoo = new CentralPackageVersion("foo", VersionRange.Parse("1.0.0"));
var centralVersionBar = new CentralPackageVersion("bar", VersionRange.Parse("2.0.0"));
var centralVersionBoom = new CentralPackageVersion("boom", VersionRange.Parse("4.0.0"));
var tfi = CreateTargetFrameworkInformation(
new List <LibraryDependency>()
{
dependencyFoo, dependencyBar, dependencyBoom
},
new List <CentralPackageVersion>()
{
centralVersionFoo, centralVersionBar, centralVersionBoom
});
// Act
DependencyGraphSpec dependencyGraphSpec = CreateDependencyGraphSpecWithCentralDependencies(tfi);
// Assert
Assert.Equal(1, dependencyGraphSpec.Projects.Count);
PackageSpec packSpec = dependencyGraphSpec.Projects[0];
IList <TargetFrameworkInformation> tfms = packSpec.TargetFrameworks;
IList <LibraryDependency> dependencies = tfms[0].Dependencies;
Assert.Equal(1, tfms.Count);
Assert.Equal(3, dependencies.Count);
Assert.Equal("[1.0.0, )", dependencies.Where(d => d.Name == "foo").First().LibraryRange.VersionRange.ToNormalizedString());
Assert.True(dependencies.Where(d => d.Name == "foo").First().VersionCentrallyManaged);
Assert.Equal("[3.0.0, )", dependencies.Where(d => d.Name == "bar").First().LibraryRange.VersionRange.ToNormalizedString());
Assert.False(dependencies.Where(d => d.Name == "bar").First().VersionCentrallyManaged);
Assert.Null(dependencies.Where(d => d.Name == "boom").First().LibraryRange.VersionRange);
}
public void AddProject_WhenDependencyIsNotInCentralPackageVersions_DependencyVersionIsAllVersions()
{
// Arrange
var dependencyFoo = new LibraryDependency(
new LibraryRange("foo", versionRange: null, LibraryDependencyTarget.Package),
LibraryIncludeFlags.All,
LibraryIncludeFlags.All,
new List <Common.NuGetLogCode>(),
autoReferenced: false,
generatePathProperty: true,
versionCentrallyManaged: false,
LibraryDependencyReferenceType.Direct,
aliases: null,
versionOverride: null);
var dependencyBar = new LibraryDependency(
new LibraryRange("bar", VersionRange.Parse("3.0.0"), LibraryDependencyTarget.Package),
LibraryIncludeFlags.All,
LibraryIncludeFlags.All,
new List <Common.NuGetLogCode>(),
autoReferenced: false,
generatePathProperty: true,
versionCentrallyManaged: false,
LibraryDependencyReferenceType.Direct,
aliases: null,
versionOverride: null);
// only a central dependency for bar not for foo
// foo will have null VersionRange
var centralVersionBar = new CentralPackageVersion("bar", VersionRange.Parse("2.0.0"));
TargetFrameworkInformation tfi = CreateTargetFrameworkInformation(
new List <LibraryDependency>()
{
dependencyFoo, dependencyBar
},
new List <CentralPackageVersion>()
{
centralVersionBar
});
// Act
DependencyGraphSpec dependencyGraphSpec = CreateDependencyGraphSpecWithCentralDependencies(tfi);
// Assert
PackageSpec packSpec = dependencyGraphSpec.Projects[0];
IList <TargetFrameworkInformation> tfms = packSpec.TargetFrameworks;
IList <LibraryDependency> dependencies = tfms[0].Dependencies;
Assert.Equal(1, tfms.Count);
Assert.Equal(2, dependencies.Count);
Assert.Null(dependencies.Where(d => d.Name == "foo").First().LibraryRange.VersionRange);
Assert.True(dependencies.Where(d => d.Name == "foo").First().VersionCentrallyManaged);
}
public void LibraryDependency_ApplyCentralVersionInformation_CPVIsMergedTpPackageVersions()
{
var dep1 = new LibraryDependency()
{
LibraryRange = new LibraryRange()
{
Name = "fooMerged"
},
};
var dep2 = new LibraryDependency()
{
LibraryRange = new LibraryRange()
{
Name = "barNotMerged", VersionRange = VersionRange.Parse("1.0.0")
},
};
var dep3 = new LibraryDependency()
{
LibraryRange = new LibraryRange()
{
Name = "bazNotMerged"
},
AutoReferenced = true
};
List <LibraryDependency> deps = new List <LibraryDependency>()
{
dep1, dep2, dep3
};
var cpv1 = new CentralPackageVersion(dep1.Name.ToLower(), VersionRange.Parse("2.0.0"));
var cpv2 = new CentralPackageVersion(dep2.Name.ToLower(), VersionRange.Parse("2.0.0"));
var cpv3 = new CentralPackageVersion(dep3.Name.ToLower(), VersionRange.Parse("2.0.0"));
Dictionary <string, CentralPackageVersion> cpvs = new Dictionary <string, CentralPackageVersion>(StringComparer.OrdinalIgnoreCase)
{
[cpv1.Name] = cpv1, [cpv2.Name] = cpv2, [cpv3.Name] = cpv3
};
// Act
LibraryDependency.ApplyCentralVersionInformation(deps, cpvs);
// Assert
Assert.True(dep1.VersionCentrallyManaged);
Assert.False(dep2.VersionCentrallyManaged);
Assert.False(dep3.VersionCentrallyManaged);
Assert.Equal("[2.0.0, )", dep1.LibraryRange.VersionRange.ToNormalizedString());
Assert.Equal("[1.0.0, )", dep2.LibraryRange.VersionRange.ToNormalizedString());
Assert.Null(dep3.LibraryRange.VersionRange);
}
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);
}
}
}
private static TargetFrameworkInformation CreateTargetFrameworkInformation(int centralVersionsDummyLoadCount = 0)
{
var nugetFramework = new NuGetFramework("net40");
var dependencyFoo = new LibraryDependency(
new LibraryRange("foo", versionRange: null, LibraryDependencyTarget.Package),
LibraryIncludeFlags.All,
LibraryIncludeFlags.All,
new List <Common.NuGetLogCode>(),
autoReferenced: false,
generatePathProperty: true,
versionCentrallyManaged: false,
LibraryDependencyReferenceType.Direct,
aliases: null,
versionOverride: null);
var centralVersionFoo = new CentralPackageVersion("foo", VersionRange.Parse("1.0.0"));
var centralVersionBar = new CentralPackageVersion("bar", VersionRange.Parse("2.0.0"));
var dependencies = new List <LibraryDependency>()
{
dependencyFoo
};
var assetTargetFallback = true;
var warn = false;
var tfi = new TargetFrameworkInformation()
{
AssetTargetFallback = assetTargetFallback,
Dependencies = dependencies,
Warn = warn,
FrameworkName = nugetFramework,
};
tfi.CentralPackageVersions.Add(centralVersionFoo.Name, centralVersionFoo);
tfi.CentralPackageVersions.Add(centralVersionBar.Name, centralVersionBar);
LibraryDependency.ApplyCentralVersionInformation(tfi.Dependencies, tfi.CentralPackageVersions);
for (int i = 0; i < centralVersionsDummyLoadCount; i++)
{
var dummy = new CentralPackageVersion($"Dummy{i}", VersionRange.Parse("1.0.0"));
tfi.CentralPackageVersions.Add(dummy.Name, dummy);
}
return(tfi);
}
public void DependencyGraphSpec_AddProjectWithCentralVersionDependencies_DependenciesAreVersionAllWhenNotInCentralVersion()
{
// Arrange
var dependencyFoo = new LibraryDependency(new LibraryRange("foo", versionRange: null, LibraryDependencyTarget.All),
LibraryDependencyType.Default,
LibraryIncludeFlags.All,
LibraryIncludeFlags.All,
new List <Common.NuGetLogCode>(),
autoReferenced: false,
generatePathProperty: true);
var dependencyBar = new LibraryDependency(new LibraryRange("bar", VersionRange.Parse("3.0.0"), LibraryDependencyTarget.All),
LibraryDependencyType.Default,
LibraryIncludeFlags.All,
LibraryIncludeFlags.All,
new List <Common.NuGetLogCode>(),
autoReferenced: false,
generatePathProperty: true);
// only a central dependency for bar not for foo
// foo will be set to VersionRange.All
var centralVersionBar = new CentralPackageVersion("bar", VersionRange.Parse("2.0.0"));
var tfi = CreateTargetFrameworkInformation(new List <LibraryDependency>()
{
dependencyFoo, dependencyBar
}, new List <CentralPackageVersion>()
{
centralVersionBar
});
// Act
var dependencyGraphSpec = CreateDependencyGraphSpecWithCentralDependencies(tfi);
// Assert
var packSpec = dependencyGraphSpec.Projects[0];
var tfms = packSpec.TargetFrameworks;
Assert.Equal(1, tfms.Count);
Assert.Equal(2, tfms[0].Dependencies.Count);
Assert.Equal("(, )", tfms[0].Dependencies.Where(d => d.Name == "foo").First().LibraryRange.VersionRange.ToNormalizedString());
Assert.True(tfms[0].Dependencies.Where(d => d.Name == "foo").First().VersionCentrallyManaged);
}
private static void AddCentralPackageVersion(Dictionary <string, Dictionary <string, CentralPackageVersion> > centralPackageVersions,
CentralPackageVersion centralPackageVersion,
IEnumerable <string> frameworks)
{
foreach (var framework in frameworks)
{
if (centralPackageVersions.ContainsKey(framework))
{
centralPackageVersions[framework].Add(centralPackageVersion.Name, centralPackageVersion);
}
else
{
var deps = new Dictionary <string, CentralPackageVersion>()
{
[centralPackageVersion.Name] = centralPackageVersion
};
centralPackageVersions.Add(framework, deps);
}
}
}
private static Dictionary <string, Dictionary <string, CentralPackageVersion> > CreateCentralVersionDependencies(IEnumerable <IMSBuildItem> items,
IList <TargetFrameworkInformation> specFrameworks)
{
IEnumerable <IMSBuildItem> centralVersions = GetItemByType(items, "CentralPackageVersion")?.Distinct(MSBuildItemIdentityComparer.Default).ToList();
var result = new Dictionary <string, Dictionary <string, CentralPackageVersion> >();
foreach (IMSBuildItem cv in centralVersions)
{
HashSet <string> tfms = GetFrameworks(cv);
string version = cv.GetProperty("VersionRange");
CentralPackageVersion centralPackageVersion = new CentralPackageVersion(cv.GetProperty("Id"), string.IsNullOrWhiteSpace(version) ? VersionRange.All : VersionRange.Parse(version));
if (tfms.Count > 0)
{
AddCentralPackageVersion(result, centralPackageVersion, tfms);
}
else
{
AddCentralPackageVersion(result, centralPackageVersion, specFrameworks.Select(f => f.TargetAlias));
}
}
return(result);
}
public void IsLockFileStillValid_TransitiveDependencyNotCentrallyManaged_DoesNotInvalidateLockFile()
{
// Arrange
var framework = CommonFrameworks.NetStandard20;
var projectName = "project";
var cpvm1 = new CentralPackageVersion("cpvm1", VersionRange.Parse("1.0.0"));
var cpvm2 = new CentralPackageVersion("cpvm2", VersionRange.Parse("1.0.0"));
var dependency1 = new LibraryDependency(
new LibraryRange("cpvm1", versionRange: null, LibraryDependencyTarget.Package),
LibraryDependencyType.Default,
LibraryIncludeFlags.All,
LibraryIncludeFlags.All,
new List <Common.NuGetLogCode>(),
autoReferenced: false,
generatePathProperty: true);
var tfm = new TargetFrameworkInformation();
tfm.FrameworkName = framework;
tfm.CentralPackageVersions.Add("cpvm1", cpvm1);
tfm.CentralPackageVersions.Add("cpvm2", cpvm2);
tfm.Dependencies.Add(dependency1);
var project = new PackageSpec(new List <TargetFrameworkInformation>()
{
tfm
});
project.RestoreMetadata = new ProjectRestoreMetadata()
{
ProjectUniqueName = projectName, CentralPackageVersionsEnabled = true
};
DependencyGraphSpec dgSpec = new DependencyGraphSpec();
dgSpec.AddRestore(projectName);
dgSpec.AddProject(project);
var lockFile1 = new PackagesLockFileBuilder()
.WithTarget(target => target
.WithFramework(CommonFrameworks.NetStandard20)
.WithDependency(dep => dep
.WithId("cpvm1")
.WithRequestedVersion(VersionRange.Parse("1.0.0"))
.WithType(PackageDependencyType.Direct))
.WithDependency(dep => dep
.WithId("otherDep")
.WithRequestedVersion(VersionRange.Parse("1.0.0"))
.WithType(PackageDependencyType.Transitive)))
.Build();
var lockFile2 = new PackagesLockFileBuilder()
.WithVersion(PackagesLockFileFormat.PackagesLockFileVersion)
.WithTarget(target => target
.WithFramework(CommonFrameworks.NetStandard20)
.WithDependency(dep => dep
.WithId("cpvm1")
.WithRequestedVersion(VersionRange.Parse("1.0.0"))
.WithType(PackageDependencyType.Direct))
.WithDependency(dep => dep
.WithId("otherDep")
.WithRequestedVersion(VersionRange.Parse("1.0.0"))
.WithType(PackageDependencyType.Transitive)))
.Build();
// Nothing changed
// different versions of lock file versions are handled
Assert.True(PackagesLockFileUtilities.IsLockFileStillValid(dgSpec, lockFile1));
Assert.True(PackagesLockFileUtilities.IsLockFileStillValid(dgSpec, lockFile2));
}
public PackagesLockFile CreateNuGetLockFile(LockFile assetsFile)
{
var lockFile = new PackagesLockFile(GetPackagesLockFileVersion(assetsFile));
var libraryLookup = assetsFile.Libraries.Where(e => e.Type == LibraryType.Package)
.ToDictionary(e => new PackageIdentity(e.Name, e.Version));
foreach (var target in assetsFile.Targets)
{
var nuGettarget = new PackagesLockFileTarget()
{
TargetFramework = target.TargetFramework,
RuntimeIdentifier = target.RuntimeIdentifier
};
var framework = assetsFile.PackageSpec.TargetFrameworks.FirstOrDefault(
f => EqualityUtility.EqualsWithNullCheck(f.FrameworkName, target.TargetFramework));
IEnumerable <LockFileTargetLibrary> libraries = target.Libraries;
// check if this is RID-based graph then only add those libraries which differ from original TFM.
if (!string.IsNullOrEmpty(target.RuntimeIdentifier))
{
var onlyTFM = assetsFile.Targets.First(t => EqualityUtility.EqualsWithNullCheck(t.TargetFramework, target.TargetFramework));
libraries = target.Libraries.Where(lib => !onlyTFM.Libraries.Any(tfmLib => tfmLib.Equals(lib)));
}
foreach (var library in libraries.Where(e => e.Type == LibraryType.Package))
{
var identity = new PackageIdentity(library.Name, library.Version);
var dependency = new LockFileDependency()
{
Id = library.Name,
ResolvedVersion = library.Version,
ContentHash = libraryLookup[identity].Sha512,
Dependencies = library.Dependencies
};
var framework_dep = framework?.Dependencies.FirstOrDefault(
dep => StringComparer.OrdinalIgnoreCase.Equals(dep.Name, library.Name));
CentralPackageVersion centralPackageVersion = null;
framework?.CentralPackageVersions.TryGetValue(library.Name, out centralPackageVersion);
if (framework_dep != null)
{
dependency.Type = PackageDependencyType.Direct;
dependency.RequestedVersion = framework_dep.LibraryRange.VersionRange;
}
// The dgspec has a list of the direct dependencies and changes in the direct dependencies will invalidate the lock file
// A dgspec does not have information about transitive dependencies
// At the restore time the transitive dependencies could be pinned from central package version management file
// By marking them will allow to evaluate when to invalidate the packages.lock.json
// in cases that a central transitive version is updated, removed or added the lock file will be invalidated
else if (centralPackageVersion != null)
{
// This is a transitive dependency that is in the list of central dependencies.
dependency.Type = PackageDependencyType.CentralTransitive;
dependency.RequestedVersion = centralPackageVersion.VersionRange;
}
else
{
dependency.Type = PackageDependencyType.Transitive;
}
nuGettarget.Dependencies.Add(dependency);
}
var projectFullPaths = assetsFile.Libraries
.Where(l => l.Type == LibraryType.Project || l.Type == LibraryType.ExternalProject)
.ToDictionary(l => new PackageIdentity(l.Name, l.Version), l => l.MSBuildProject);
foreach (var projectReference in libraries.Where(e => e.Type == LibraryType.Project || e.Type == LibraryType.ExternalProject))
{
var projectIdentity = new PackageIdentity(projectReference.Name, projectReference.Version);
var projectFullPath = projectFullPaths[projectIdentity];
var id = PathUtility.GetStringComparerBasedOnOS().Equals(Path.GetFileNameWithoutExtension(projectFullPath), projectReference.Name)
? projectReference.Name.ToLowerInvariant()
: projectReference.Name;
var dependency = new LockFileDependency()
{
Id = id,
Dependencies = projectReference.Dependencies,
Type = PackageDependencyType.Project
};
nuGettarget.Dependencies.Add(dependency);
}
nuGettarget.Dependencies = nuGettarget.Dependencies.OrderBy(d => d.Type).ToList();
lockFile.Targets.Add(nuGettarget);
}
return(lockFile);
}
