public TestPackage DependsOn(string id, string version, LibraryDependencyTarget target = LibraryDependencyTarget.All, bool versionCentrallyManaged = false, LibraryDependencyReferenceType?libraryDependencyReferenceType = null, LibraryIncludeFlags?privateAssets = null)
{
var libraryDependency = new LibraryDependency
{
LibraryRange =
new LibraryRange
{
Name = id,
VersionRange = VersionRange.Parse(version),
TypeConstraint = target
},
VersionCentrallyManaged = versionCentrallyManaged,
};
if (privateAssets != null)
{
libraryDependency.SuppressParent = privateAssets.Value;
}
if (libraryDependencyReferenceType != null)
{
libraryDependency.ReferenceType = libraryDependencyReferenceType.Value;
}
_dependencies.Add(libraryDependency);
return(this);
}
private static LibraryType GetLibraryTypeFromLibraryDependencyTarget(LibraryDependencyTarget target)
{
switch (target)
{
case LibraryDependencyTarget.Package:
return(LibraryType.Package);
case LibraryDependencyTarget.Project:
return(LibraryType.Project);
case LibraryDependencyTarget.Reference:
return(LibraryType.Reference);
case LibraryDependencyTarget.Assembly:
return(LibraryType.Assembly);
case LibraryDependencyTarget.ExternalProject:
return(LibraryType.ExternalProject);
case LibraryDependencyTarget.WinMD:
return(LibraryType.WinMD);
default:
return(LibraryType.Unresolved);
}
}
public void LibraryDependencyTargetUtils_Parse(string input, LibraryDependencyTarget expected)
{
// Arrange & Act
var actual = LibraryDependencyTargetUtils.Parse(input);
// Assert
Assert.Equal(expected, actual);
}
public GraphNode <RemoteResolveResult> GetNode(string id, string range, LibraryDependencyTarget target, string version, LibraryType type)
{
return(new GraphNode <RemoteResolveResult>(new LibraryRange(id.ToUpperInvariant(), VersionRange.Parse(range), LibraryDependencyTarget.All))
{
Item = new GraphItem <RemoteResolveResult>(
new LibraryIdentity(
id.ToLowerInvariant(),
new NuGetVersion(version),
type))
});
}
private void ScanLibraries(LockFileTarget target,
LockFileLookup lockFileLookup,
Dictionary <LibraryKey, LibraryDescription> libraries,
MSBuildDependencyProvider msbuildResolver,
PackageDependencyProvider packageResolver,
ProjectDependencyProvider projectResolver)
{
foreach (var library in target.Libraries)
{
LibraryDescription description = null;
LibraryDependencyTarget type = LibraryDependencyTarget.All;
if (string.Equals(library.Type, "project"))
{
var projectLibrary = lockFileLookup.GetProject(library.Name);
if (projectLibrary != null)
{
if (MSBuildDependencyProvider.IsMSBuildProjectLibrary(projectLibrary))
{
description = msbuildResolver.GetDescription(TargetFramework, projectLibrary, library, IsDesignTime);
type = LibraryDependencyTarget.Project;
}
else
{
var path = Path.GetFullPath(Path.Combine(ProjectDirectory, projectLibrary.Path));
description = projectResolver.GetDescription(library.Name, path, library, ProjectResolver);
type = LibraryDependencyTarget.Project;
}
}
}
else
{
var packageEntry = lockFileLookup.GetPackage(library.Name, library.Version);
if (packageEntry != null)
{
description = packageResolver.GetDescription(TargetFramework, packageEntry, library);
}
type = LibraryDependencyTarget.Package;
}
description = description ??
UnresolvedDependencyProvider.GetDescription(
new ProjectLibraryDependency
{
LibraryRange = new LibraryRange(library.Name, type)
},
target.TargetFramework);
libraries.Add(new LibraryKey(library.Name), description);
}
}
public async Task FindLibraryEntryAsync_LogsOnlyPackages(LibraryDependencyTarget libraryDependencyTarget)
{
// Arrange
const string packageX = "x", version = "1.0.0-beta.1", source = "source";
var range = new LibraryRange(packageX, VersionRange.Parse(version), libraryDependencyTarget);
var cacheContext = new SourceCacheContext();
var testLogger = new TestLogger();
var framework = NuGetFramework.Parse("net45");
var token = CancellationToken.None;
var edge = new GraphEdge <RemoteResolveResult>(null, null, null);
var actualIdentity = new LibraryIdentity(packageX, NuGetVersion.Parse(version), LibraryType.Package);
var dependencies = new[] { new LibraryDependency()
{
LibraryRange = new LibraryRange("y", VersionRange.All, LibraryDependencyTarget.Package)
} };
var dependencyInfo = LibraryDependencyInfo.Create(actualIdentity, framework, dependencies);
//package source mapping configuration
Dictionary <string, IReadOnlyList <string> > patterns = new();
patterns.Add(source, new List <string>()
{
packageX
});
PackageSourceMapping sourceMappingConfiguration = new(patterns);
var context = new RemoteWalkContext(cacheContext, sourceMappingConfiguration, testLogger);
var remoteProvider = new Mock <IRemoteDependencyProvider>();
remoteProvider.Setup(e => e.FindLibraryAsync(range, It.IsAny <NuGetFramework>(), It.IsAny <SourceCacheContext>(), testLogger, token))
.ReturnsAsync(actualIdentity);
remoteProvider.SetupGet(e => e.IsHttp).Returns(true);
remoteProvider.SetupGet(e => e.Source).Returns(new PackageSource(source));
remoteProvider.Setup(e => e.GetDependenciesAsync(It.IsAny <LibraryIdentity>(), It.IsAny <NuGetFramework>(), It.IsAny <SourceCacheContext>(), testLogger, token))
.ReturnsAsync(dependencyInfo);
context.RemoteLibraryProviders.Add(remoteProvider.Object);
// Act
var result = await ResolverUtility.FindLibraryEntryAsync(range, framework, null, context, token);
// Assert
Assert.Equal(0, testLogger.Errors);
testLogger.DebugMessages.TryPeek(out string message);
if (libraryDependencyTarget == LibraryDependencyTarget.Package)
{
Assert.Equal($"Package source mapping matches found for package ID '{packageX}' are: '{source}'.", message);
Assert.Equal(version, result.Key.Version.ToString());
Assert.Equal(source, result.Data.Match.Provider.Source.Name);
}
else
{
Assert.Equal(message, null);
}
}
public TestPackage DependsOn(string id, LibraryDependencyTarget target = LibraryDependencyTarget.All)
{
_dependencies.Add(new LibraryDependency
{
LibraryRange = new LibraryRange
{
Name = id,
TypeConstraint = target
}
});
return(this);
}
private static bool ValidateDependencyTarget(LibraryDependencyTarget targetValue)
{
var isValid = false;
switch (targetValue)
{
case LibraryDependencyTarget.Package:
case LibraryDependencyTarget.Project:
case LibraryDependencyTarget.ExternalProject:
isValid = true;
break;
}
return(isValid);
}
public TestPackage DependsOn(string id, string version, LibraryDependencyTarget target = LibraryDependencyTarget.All, bool versionCentrallyManaged = false, LibraryDependencyReferenceType libraryDependencyReferenceType = LibraryDependencyReferenceType.Direct)
{
_dependencies.Add(new LibraryDependency
{
LibraryRange = new LibraryRange
{
Name = id,
VersionRange = VersionRange.Parse(version),
TypeConstraint = target
},
VersionCentrallyManaged = versionCentrallyManaged,
ReferenceType = libraryDependencyReferenceType,
});
return(this);
}
[InlineData(LibraryDependencyTarget.Package, LibraryDependencyTarget.Assembly, false)] // different
public void LibraryRange_Equals_TypeConstraint(
LibraryDependencyTarget typeConstraintA,
LibraryDependencyTarget typeConstraintB,
bool expected)
{
// Arrange
var version = VersionRange.Parse("1.0.0");
var rangeA = new LibraryRange("packageA", version, typeConstraintA);
var rangeB = new LibraryRange("packageA", version, typeConstraintB);
// Act
var actual = rangeA.Equals(rangeB);
// Assert
Assert.Equal(expected, actual);
}
/// <summary>
/// Convert type flags to a friendly string.
/// </summary>
public static string GetFlagString(LibraryDependencyTarget flags)
{
if (flags == LibraryDependencyTarget.None)
{
return("none");
}
if (flags == LibraryDependencyTarget.All)
{
return("all");
}
var flagStrings = new List <string>();
foreach (LibraryDependencyTarget value in Enum.GetValues(typeof(LibraryDependencyTarget)))
{
if (value != LibraryDependencyTarget.None && flags.HasFlag(value))
{
flagStrings.Add(value.ToString().ToLowerInvariant());
}
}
return(string.Join(",", flagStrings));
}
public LibraryRange(string name, VersionRange versionRange, LibraryDependencyTarget typeConstraint)
{
Name = name;
VersionRange = versionRange;
TypeConstraint = typeConstraint;
}
/// <summary>
/// True if the type constraint allows the flag.
/// </summary>
public bool TypeConstraintAllows(LibraryDependencyTarget flag)
{
return((TypeConstraint & flag) == flag);
}
/// <summary>
/// Checks if a LibraryDependencyTarget is a project.
/// </summary>
/// <param name="type">LibraryDependencyTarget to be checked.</param>
/// <returns>True if a LibraryDependencyTarget is Project or ExternalProject.</returns>
private static bool IsProject(LibraryDependencyTarget type)
{
return(type == LibraryDependencyTarget.ExternalProject || type == LibraryDependencyTarget.Project);
}
public GraphNode <RemoteResolveResult> GetUnresolvedNode(string id, string range, LibraryDependencyTarget target)
{
return(new GraphNode <RemoteResolveResult>(new LibraryRange(id.ToUpperInvariant(), VersionRange.Parse(range), target)));
}
public bool SupportsType(LibraryDependencyTarget libraryType)
{
return((libraryType & LibraryDependencyTarget.Package) == LibraryDependencyTarget.Package);
}
public bool SupportsType(LibraryDependencyTarget libraryType)
{
return((libraryType & (LibraryDependencyTarget.Project | LibraryDependencyTarget.ExternalProject)) != LibraryDependencyTarget.None);
}
/// <summary>
/// True if any flags are allowed by the constraint.
/// </summary>
public bool TypeConstraintAllowsAnyOf(LibraryDependencyTarget flag)
{
return((TypeConstraint & flag) != LibraryDependencyTarget.None);
}
public LibraryRange(string name, LibraryDependencyTarget typeConstraint) : this(name, null, typeConstraint)
{
}
public bool SupportsType(LibraryDependencyTarget libraryTypeFlag)
{
return(libraryTypeFlag == LibraryDependencyTarget.Project);
}
