private static async Task <RestoreTargetGraph> GetPlatformSpecificGraph(RestoreTargetGraph independentGraph,
string package, string version, NuGetFramework framework, string runtimeIdentifier,
RemoteWalkContext context, LocalPackageExtractor extractor)
{
var graphTask = independentGraph.Flattened
.Where(m => m.Data?.Match?.Library?.Type == LibraryType.Package)
.Select(GetRuntimeGraphTask);
var graphs = (await Task.WhenAll(graphTask))
.Where(i => i != null);
var runtimeGraph = graphs.Aggregate(RuntimeGraph.Empty, RuntimeGraph.Merge);
// This results in additional entries
var resultWin = await new RemoteDependencyWalker(context).WalkAsync(
new LibraryRange(package, VersionRange.Parse(version), LibraryDependencyTarget.All),
framework,
runtimeGraph: runtimeGraph,
recursive: true,
runtimeIdentifier: runtimeIdentifier);
return(RestoreTargetGraph.Create(runtimeGraph, new[]
{
resultWin
}, context, context.Logger, framework, runtimeIdentifier));
async Task <RuntimeGraph> GetRuntimeGraphTask(GraphItem <RemoteResolveResult> item)
{
var packageIdentity = ToPackageIdentity(item.Data.Match);
var localPackageSourceInfo = await extractor.EnsureLocalPackage(item.Data.Match.Provider, packageIdentity);
return(localPackageSourceInfo?.Package?.RuntimeGraph);
}
}
public static async Task Main(string[] args)
{
var builder = WebAssemblyHostBuilder.CreateDefault(args);
builder.RootComponents.Add <App>("app");
builder.Services.AddSingleton(serviceProvider => (IJSInProcessRuntime)serviceProvider.GetRequiredService <IJSRuntime>());
builder.Services.AddSingleton(serviceProvider => (IJSUnmarshalledRuntime)serviceProvider.GetRequiredService <IJSRuntime>());
builder.Services.AddSingleton(_ => new HttpClient {
BaseAddress = new Uri(builder.HostEnvironment.BaseAddress)
});
builder.Services.AddSingleton <SnippetsService>();
builder.Services.AddSingleton <CompilationService>();
builder.Services.AddSingleton <NuGetRemoteDependencyProvider>();
builder.Services.AddTransient <NuGetPackageManagementService>();
builder.Services.AddSingleton(serviceProvider =>
{
var remoteWalkContext = new RemoteWalkContext(NullSourceCacheContext.Instance, NullLogger.Instance);
var remoteDependencyProvider = serviceProvider.GetRequiredService <NuGetRemoteDependencyProvider>();
remoteWalkContext.RemoteLibraryProviders.Add(remoteDependencyProvider);
return(new RemoteDependencyWalker(remoteWalkContext));
});
builder.Services
.AddOptions <SnippetsOptions>()
.Configure <IConfiguration>((options, configuration) => configuration.GetSection("Snippets").Bind(options));
builder.Logging.Services.AddSingleton <ILoggerProvider, HandleCriticalUserComponentExceptionsLoggerProvider>();
var jsRuntime = GetJsRuntime();
try
{
await LoadResourcesAsync(jsRuntime);
if (TryExecuteUserDefinedConfiguration(builder))
{
// If the user defined configuration code has executed, the user components DLL is now
// loaded in the app domain so we reset the DLL in the storage for the next app load
jsRuntime.InvokeUnmarshalled <string, object>(
"App.CodeExecution.updateUserComponentsDll",
CoreConstants.DefaultUserComponentsAssemblyBytes);
}
}
catch (Exception ex)
{
// We shouldn't throw during app start so just give the user the info that an exception has been thrown,
// update the user components DLL to make sure the app will run on reload and continue the app execution
var actualException = ex is TargetInvocationException tie ? tie.InnerException : ex;
Console.Error.WriteLine($"Error on app startup: {actualException}");
jsRuntime.InvokeUnmarshalled <string, object>(
"App.CodeExecution.updateUserComponentsDll",
CoreConstants.DefaultUserComponentsAssemblyBytes);
}
await builder.Build().RunAsync();
}
public async Task NearestWinsOverridesStrictDependencyButDowngradeWarns()
{
var context = new RemoteWalkContext();
var provider = new DependencyProvider();
provider.Package("A", "1.0")
.DependsOn("B", "2.0")
.DependsOn("C", "2.0")
.DependsOn("D", "1.0");
provider.Package("B", "2.0")
.DependsOn("D", "[2.0]");
provider.Package("C", "2.0")
.DependsOn("D", "[1.0]");
provider.Package("D", "1.0");
provider.Package("D", "2.0");
provider.Package("D", "3.0");
context.LocalLibraryProviders.Add(provider);
var walker = new RemoteDependencyWalker(context);
var node = await DoWalkAsync(walker, "A");
var result = node.Analyze();
Assert.Equal(0, result.VersionConflicts.Count);
Assert.Equal(1, result.Downgrades.Count);
var downgraded = result.Downgrades[0].DowngradedFrom;
var downgradedBy = result.Downgrades[0].DowngradedTo;
AssertPath(downgraded, "A 1.0", "B 2.0", "D 2.0");
AssertPath(downgradedBy, "A 1.0", "D 1.0");
}
public async Task DowngradeThenUpgradeThenDowngrade()
{
var context = new RemoteWalkContext();
var provider = new DependencyProvider();
provider.Package("A", "1.0")
.DependsOn("B", "1.0")
.DependsOn("C", "1.0");
provider.Package("B", "1.0");
provider.Package("C", "1.0")
.DependsOn("B", "2.0")
.DependsOn("D", "1.0");
provider.Package("B", "2.0");
provider.Package("D", "1.0")
.DependsOn("B", "1.0");
context.LocalLibraryProviders.Add(provider);
var walker = new RemoteDependencyWalker(context);
var node = await DoWalkAsync(walker, "A");
var result = node.Analyze();
Assert.Equal(1, result.Downgrades.Count);
var downgraded = result.Downgrades[0].DowngradedFrom;
var downgradedBy = result.Downgrades[0].DowngradedTo;
AssertPath(downgraded, "A 1.0", "C 1.0", "B 2.0");
AssertPath(downgradedBy, "A 1.0", "B 1.0");
}
public async Task TryResolveConflicts_ThrowsIfPackageConstraintCannotBeResolved()
{
var context = new RemoteWalkContext();
var provider = new DependencyProvider();
provider.Package("Root", "1.0")
.DependsOn("A", "1.0")
.DependsOn("B", "2.0");
provider.Package("A", "1.0")
.DependsOn("C", "(1.0, 1.4]");
provider.Package("B", "2.0")
.DependsOn("C", "1.8");
provider.Package("C", "1.3.8");
provider.Package("C", "1.8");
context.LocalLibraryProviders.Add(provider);
var walker = new RemoteDependencyWalker(context);
var node = await DoWalkAsync(walker, "Root");
var result = node.Analyze();
Assert.Equal(1, result.VersionConflicts.Count);
var conflict = result.VersionConflicts[0];
var c1 = conflict.Selected;
var c2 = conflict.Conflicting;
AssertPath(c1, "Root 1.0", "B 2.0", "C 1.8");
AssertPath(c2, "Root 1.0", "A 1.0", "C 1.3.8");
}
public async Task StrictDependenciesButNoConflict()
{
var context = new RemoteWalkContext();
var provider = new DependencyProvider();
provider.Package("A", "1.0")
.DependsOn("B", "2.0")
.DependsOn("C", "2.0");
provider.Package("B", "2.0")
.DependsOn("D", "[2.0]");
provider.Package("C", "2.0")
.DependsOn("D", "[1.0, 3.0]");
provider.Package("D", "1.0");
provider.Package("D", "2.0");
context.LocalLibraryProviders.Add(provider);
var walker = new RemoteDependencyWalker(context);
var node = await DoWalkAsync(walker, "A");
var result = node.Analyze();
Assert.Equal(0, result.VersionConflicts.Count);
}
public async Task SingleConflictWhereConflictingDependenyIsUnresolved()
{
var context = new RemoteWalkContext();
var provider = new DependencyProvider();
provider.Package("A", "1.0")
.DependsOn("B", "2.0")
.DependsOn("C", "2.0");
provider.Package("B", "2.0")
.DependsOn("D", "[2.0]");
provider.Package("C", "2.0")
.DependsOn("D", "[1.0]");
provider.Package("D", "2.0");
context.LocalLibraryProviders.Add(provider);
var walker = new RemoteDependencyWalker(context);
var node = await DoWalkAsync(walker, "A");
var result = node.Analyze();
Assert.Equal(1, result.VersionConflicts.Count);
var conflict = result.VersionConflicts[0];
var c1 = conflict.Selected;
var c2 = conflict.Conflicting;
AssertPath(c1, "A 1.0", "B 2.0", "D 2.0");
AssertPath(c2, "A 1.0", "C 2.0", "D 1.0");
}
public async Task UpgradeThenDowngradeThenEqual()
{
var context = new RemoteWalkContext();
var provider = new DependencyProvider();
provider.Package("A", "1.0")
.DependsOn("B", "2.0")
.DependsOn("C", "1.0");
provider.Package("B", "1.0");
provider.Package("C", "1.0")
.DependsOn("B", "1.0")
.DependsOn("D", "1.0");
provider.Package("B", "2.0");
provider.Package("D", "1.0")
.DependsOn("B", "2.0");
context.LocalLibraryProviders.Add(provider);
var walker = new RemoteDependencyWalker(context);
var node = await DoWalkAsync(walker, "A");
var result = node.Analyze();
Assert.Equal(0, result.Downgrades.Count);
}
public async Task GivenAMultipleSourcesVerifyInfosReturned()
{
var versions1 = new[]
{
NuGetVersion.Parse("1.0.0"),
NuGetVersion.Parse("2.0.0"),
NuGetVersion.Parse("3.0.0-beta"),
};
var versions2 = new[]
{
NuGetVersion.Parse("1.0.0")
};
var provider1 = GetProvider("http://nuget.org/a/", versions1);
var provider2 = GetProvider("http://nuget.org/b/", versions2);
var cacheContext = new Mock <SourceCacheContext>();
var remoteWalkContext = new RemoteWalkContext(cacheContext.Object, NullLogger.Instance);
remoteWalkContext.RemoteLibraryProviders.Add(provider1.Object);
remoteWalkContext.RemoteLibraryProviders.Add(provider2.Object);
var infos = await UnresolvedMessages.GetSourceInfosForIdAsync("a", VersionRange.Parse("1.0.0"), remoteWalkContext, NullLogger.Instance, CancellationToken.None);
infos.Count.Should().Be(2);
infos[0].Value.ShouldBeEquivalentTo(versions1);
infos[1].Value.ShouldBeEquivalentTo(versions2);
infos[0].Key.Source.Should().Be("http://nuget.org/a/");
infos[1].Key.Source.Should().Be("http://nuget.org/b/");
}
/// <summary>
/// Log errors for missing dependencies.
/// </summary>
public static async Task LogAsync(IEnumerable <IRestoreTargetGraph> graphs, RemoteWalkContext context, ILogger logger, CancellationToken token)
{
var tasks = graphs.SelectMany(graph => graph.Unresolved.Select(e => GetMessageAsync(graph.TargetGraphName, e, context.RemoteLibraryProviders, context.CacheContext, logger, token))).ToArray();
var messages = await Task.WhenAll(tasks);
await logger.LogMessagesAsync(DiagnosticUtility.MergeOnTargetGraph(messages));
}
private LockFile BuildLockFile(
LockFile existingLockFile,
PackageSpec project,
IEnumerable <RestoreTargetGraph> graphs,
NuGetv3LocalRepository localRepository,
RemoteWalkContext contextForProject,
IEnumerable <ToolRestoreResult> toolRestoreResults,
bool relockFile)
{
// Build the lock file
LockFile lockFile;
if (existingLockFile != null && existingLockFile.IsLocked)
{
// No lock file to write!
lockFile = existingLockFile;
}
else
{
lockFile = new LockFileBuilder(_request.LockFileVersion, _logger, _includeFlagGraphs)
.CreateLockFile(
existingLockFile,
project,
graphs,
localRepository,
contextForProject,
toolRestoreResults);
// If the lock file was locked originally but we are re-locking it, well... re-lock it :)
lockFile.IsLocked = relockFile;
}
return(lockFile);
}
private async Task <RestoreTargetGraph> WalkDependenciesAsync(LibraryRange projectRange,
NuGetFramework framework,
string runtimeIdentifier,
RuntimeGraph runtimeGraph,
RemoteDependencyWalker walker,
RemoteWalkContext context,
CancellationToken token)
{
var name = FrameworkRuntimePair.GetTargetGraphName(framework, runtimeIdentifier);
var graphs = new List <GraphNode <RemoteResolveResult> >
{
await walker.WalkAsync(
projectRange,
framework,
runtimeIdentifier,
runtimeGraph,
recursive : true)
};
// Resolve conflicts
await _logger.LogAsync(LogLevel.Verbose, string.Format(CultureInfo.CurrentCulture, Strings.Log_ResolvingConflicts, name));
// Flatten and create the RestoreTargetGraph to hold the packages
return(RestoreTargetGraph.Create(runtimeGraph, graphs, context, _logger, framework, runtimeIdentifier));
}
public async Task DeepCycleCheck()
{
var context = new RemoteWalkContext();
var provider = new DependencyProvider();
provider.Package("A", "1.0")
.DependsOn("B", "2.0");
provider.Package("B", "2.0")
.DependsOn("C", "2.0");
provider.Package("C", "2.0")
.DependsOn("D", "1.0")
.DependsOn("E", "1.0");
provider.Package("D", "1.0");
provider.Package("E", "1.0")
.DependsOn("A", "1.0");
context.LocalLibraryProviders.Add(provider);
var walker = new RemoteDependencyWalker(context);
var node = await DoWalkAsync(walker, "A");
var result = node.Analyze();
Assert.Equal(1, result.Cycles.Count);
var cycle = result.Cycles[0];
AssertPath(cycle, "A 1.0", "B 2.0", "C 2.0", "E 1.0", "A 1.0");
}
private RemoteWalkContext CreateRemoteWalkContext(ISettings settings, SourceCacheContext cache, ILogger logger)
{
// nuget.org etc.
var globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(settings);
var localRepository = Repository.Factory.GetCoreV3(globalPackagesFolder, FeedType.FileSystemV3);
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3());
var context = new RemoteWalkContext(cache, logger);
context.LocalLibraryProviders.Add(new SourceRepositoryDependencyProvider(localRepository, logger, cache,
ignoreFailedSources: true,
fileCache: new LocalPackageFileCache(),
ignoreWarning: true,
isFallbackFolderSource: false));
foreach (var remoteRepository in sourceRepositoryProvider.GetRepositories())
{
context.RemoteLibraryProviders.Add(new SourceRepositoryDependencyProvider(remoteRepository, logger, cache,
ignoreFailedSources: cache.IgnoreFailedSources,
fileCache: new LocalPackageFileCache(),
ignoreWarning: false,
isFallbackFolderSource: false));
}
return(context);
}
public async Task AllowPreleaseVersionNoConflict()
{
var context = new RemoteWalkContext();
var provider = new DependencyProvider();
provider.Package("A", "1.0-beta")
.DependsOn("B", "1.0")
.DependsOn("C", "1.0-beta")
.DependsOn("E", "1.0");
provider.Package("B", "1.0")
.DependsOn("D", "1.0");
provider.Package("C", "1.0-beta")
.DependsOn("D", "1.1-beta");
provider.Package("E", "1.0")
.DependsOn("D", "0.1");
context.LocalLibraryProviders.Add(provider);
var walker = new RemoteDependencyWalker(context);
var node = await DoWalkAsync(walker, "A");
var result = node.Analyze();
Assert.Equal(0, result.VersionConflicts.Count);
}
private Task <RestoreTargetGraph[]> WalkRuntimeDependenciesAsync(LibraryRange projectRange,
RestoreTargetGraph graph,
IEnumerable <string> runtimeIds,
RemoteDependencyWalker walker,
RemoteWalkContext context,
RuntimeGraph runtimes,
CancellationToken token)
{
var resultGraphs = new List <Task <RestoreTargetGraph> >();
foreach (var runtimeName in runtimeIds)
{
_logger.LogVerbose(string.Format(CultureInfo.CurrentCulture, Strings.Log_RestoringPackages, FrameworkRuntimePair.GetName(graph.Framework, runtimeName)));
resultGraphs.Add(WalkDependenciesAsync(projectRange,
graph.Framework,
runtimeName,
runtimes,
walker,
context,
token));
}
return(Task.WhenAll(resultGraphs));
}
public async Task GivenAnUnresolvedPackageWithNoVersionsAndMultipleSourcesVerifyMessage()
{
var range = new LibraryRange("x", LibraryDependencyTarget.Package);
var versions = new List <NuGetVersion>();
var token = CancellationToken.None;
var logger = new TestLogger();
var provider1 = GetProvider("http://nuget.org/a/", versions);
var provider2 = GetProvider("http://nuget.org/b/", versions);
var cacheContext = new Mock <SourceCacheContext>();
var remoteWalkContext = new RemoteWalkContext(cacheContext.Object, NullLogger.Instance);
remoteWalkContext.RemoteLibraryProviders.Add(provider1.Object);
remoteWalkContext.RemoteLibraryProviders.Add(provider2.Object);
var graph = new Mock <IRestoreTargetGraph>();
graph.SetupGet(e => e.TargetGraphName).Returns("abc");
var message = await UnresolvedMessages.GetMessageAsync(graph.Object, range, remoteWalkContext, logger, token);
message.Code.Should().Be(NuGetLogCode.NU1101);
message.LibraryId.Should().Be("x");
message.Message.Should().Be("Unable to find package x. No packages exist with this id in source(s): http://nuget.org/a/, http://nuget.org/b/");
message.TargetGraphs.ShouldBeEquivalentTo(new[] { "abc" });
message.Level.Should().Be(LogLevel.Error);
}
private List <ExternalProjectReference> GetProjectReferences(RemoteWalkContext context)
{
// External references
var updatedExternalProjects = new List <ExternalProjectReference>();
if (_request.ExternalProjects.Count == 0)
{
// If no projects exist add the current project.json file to the project
// list so that it can be resolved.
updatedExternalProjects.Add(ToExternalProjectReference(_request.Project));
}
else if (_request.ExternalProjects.Count > 0)
{
// There should be at most one match in the external projects.
var rootProjectMatches = _request.ExternalProjects.Where(proj =>
string.Equals(
_request.Project.Name,
proj.PackageSpecProjectName,
StringComparison.OrdinalIgnoreCase))
.ToList();
if (rootProjectMatches.Count > 1)
{
throw new InvalidOperationException($"Ambiguous project name '{_request.Project.Name}'.");
}
var rootProject = rootProjectMatches.SingleOrDefault();
if (rootProject != null)
{
// Replace the project spec with the passed in package spec,
// for installs which are done in memory first this will be
// different from the one on disk
updatedExternalProjects.AddRange(_request.ExternalProjects
.Where(project =>
!project.UniqueName.Equals(rootProject.UniqueName, StringComparison.Ordinal)));
var updatedReference = new ExternalProjectReference(
rootProject.UniqueName,
_request.Project,
rootProject.MSBuildProjectPath,
rootProject.ExternalProjectReferences);
updatedExternalProjects.Add(updatedReference);
}
}
else
{
// External references were passed, but the top level project wasn't found.
// This is always due to an internal issue and typically caused by errors
// building the project closure.
Debug.Fail("RestoreRequest.ExternalProjects contains references, but does not contain the top level references. Add the project we are restoring for.");
throw new InvalidOperationException($"Missing external reference metadata for {_request.Project.Name}");
}
return(updatedExternalProjects);
}
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 async Task FindPackage_VerifyFloatingPackageIsRequiredOnlyFromASingleSource()
{
// Arrange
var range = new LibraryRange("x", VersionRange.Parse("1.0.0-*"), LibraryDependencyTarget.Package);
var cacheContext = new SourceCacheContext();
var testLogger = new TestLogger();
var framework = NuGetFramework.Parse("net45");
var context = new RemoteWalkContext(cacheContext, testLogger);
var token = CancellationToken.None;
var edge = new GraphEdge <RemoteResolveResult>(null, null, null);
var actualIdentity = new LibraryIdentity("x", NuGetVersion.Parse("1.0.0-beta.1"), LibraryType.Package);
var higherIdentity = new LibraryIdentity("x", NuGetVersion.Parse("1.0.0-beta.2"), LibraryType.Package);
var dependencies = new[] { new LibraryDependency()
{
LibraryRange = new LibraryRange("y", VersionRange.All, LibraryDependencyTarget.Package)
} };
var dependencyInfo = LibraryDependencyInfo.Create(actualIdentity, framework, dependencies);
var dependencyInfo2 = LibraryDependencyInfo.Create(higherIdentity, framework, dependencies);
var downloadCount = 0;
// Source1 returns 1.0.0-beta.1
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("test"));
remoteProvider.Setup(e => e.GetDependenciesAsync(It.IsAny <LibraryIdentity>(), It.IsAny <NuGetFramework>(), It.IsAny <SourceCacheContext>(), testLogger, token))
.ReturnsAsync(dependencyInfo)
.Callback(() => ++ downloadCount);
context.RemoteLibraryProviders.Add(remoteProvider.Object);
// Source2 returns 1.0.0-beta.2
var remoteProvider2 = new Mock <IRemoteDependencyProvider>();
remoteProvider2.Setup(e => e.FindLibraryAsync(range, It.IsAny <NuGetFramework>(), It.IsAny <SourceCacheContext>(), testLogger, token))
.ReturnsAsync(higherIdentity);
remoteProvider2.SetupGet(e => e.IsHttp).Returns(true);
remoteProvider2.SetupGet(e => e.Source).Returns(new PackageSource("test"));
remoteProvider2.Setup(e => e.GetDependenciesAsync(It.IsAny <LibraryIdentity>(), It.IsAny <NuGetFramework>(), It.IsAny <SourceCacheContext>(), testLogger, token))
.ReturnsAsync(dependencyInfo2)
.Callback(() => ++ downloadCount);
context.RemoteLibraryProviders.Add(remoteProvider2.Object);
// Act
var result = await ResolverUtility.FindLibraryEntryAsync(range, framework, null, edge, context, token);
// Assert
// Verify only one download happened
Assert.Equal(1, downloadCount);
Assert.Equal("1.0.0-beta.2", result.Key.Version.ToString());
}
public LockFile CreateLockFile(LockFile previousLockFile,
PackageSpec project,
IEnumerable <RestoreTargetGraph> targetGraphs,
IReadOnlyList <NuGetv3LocalRepository> localRepositories,
RemoteWalkContext context)
{
return(CreateLockFile(previousLockFile,
project,
targetGraphs,
localRepositories,
context,
new LockFileBuilderCache()));
}
private Task <RestoreTargetGraph> WalkDependenciesAsync(LibraryRange projectRange,
NuGetFramework framework,
RemoteDependencyWalker walker,
RemoteWalkContext context,
CancellationToken token)
{
return(WalkDependenciesAsync(projectRange,
framework,
runtimeIdentifier: null,
runtimeGraph: RuntimeGraph.Empty,
walker: walker,
context: context,
token: token));
}
public async Task DoubleDowngrade()
{
var context = new RemoteWalkContext();
var provider = new DependencyProvider();
provider.Package("A", "1.0")
.DependsOn("B", "0.7")
.DependsOn("C", "1.0");
provider.Package("B", "0.7");
provider.Package("C", "1.0")
.DependsOn("B", "0.8")
.DependsOn("D", "1.0");
provider.Package("B", "0.8");
provider.Package("D", "1.0")
.DependsOn("B", "1.0");
provider.Package("B", "1.0");
context.LocalLibraryProviders.Add(provider);
var walker = new RemoteDependencyWalker(context);
var node = await DoWalkAsync(walker, "A");
var downgrades = new List <Tuple <GraphNode <RemoteResolveResult>, GraphNode <RemoteResolveResult> > >();
var cycles = new List <GraphNode <RemoteResolveResult> >();
var result = node.Analyze();
Assert.Equal(2, result.Downgrades.Count);
var d0 = result.Downgrades[0];
var d0To = d0.DowngradedFrom;
var d0By = d0.DowngradedTo;
AssertPath(d0To, "A 1.0", "C 1.0", "B 0.8");
AssertPath(d0By, "A 1.0", "B 0.7");
var d1 = result.Downgrades[1];
var d1To = d1.DowngradedFrom;
var d1By = d1.DowngradedTo;
AssertPath(d1To, "A 1.0", "C 1.0", "D 1.0", "B 1.0");
AssertPath(d1By, "A 1.0", "B 0.7");
}
private static RemoteWalkContext CreateRemoteWalkContext(RestoreRequest request)
{
var context = new RemoteWalkContext();
foreach (var provider in request.DependencyProviders.LocalProviders)
{
context.LocalLibraryProviders.Add(provider);
}
foreach (var provider in request.DependencyProviders.RemoteProviders)
{
context.RemoteLibraryProviders.Add(provider);
}
return(context);
}
private static async Task <RestoreLogMessage> GetMessage(LibraryRange range, List <NuGetVersion> versions)
{
var token = CancellationToken.None;
var logger = new TestLogger();
var provider = GetProvider("http://nuget.org/a/", versions);
var cacheContext = new Mock <SourceCacheContext>();
var remoteWalkContext = new RemoteWalkContext(cacheContext.Object, NullLogger.Instance);
remoteWalkContext.RemoteLibraryProviders.Add(provider.Object);
var graph = new Mock <IRestoreTargetGraph>();
graph.SetupGet(e => e.TargetGraphName).Returns("abc");
var message = await UnresolvedMessages.GetMessageAsync(graph.Object, range, remoteWalkContext, logger, token);
return(message);
}
private static async Task <RestoreLogMessage> GetMessage(LibraryRange range, List <NuGetVersion> versions)
{
var token = CancellationToken.None;
var logger = new TestLogger();
var provider = GetProvider("http://nuget.org/a/", versions);
var cacheContext = new Mock <SourceCacheContext>();
var remoteWalkContext = new RemoteWalkContext(cacheContext.Object, PackageSourceMapping.GetPackageSourceMapping(NullSettings.Instance), NullLogger.Instance);
var remoteLibraryProviders = new List <IRemoteDependencyProvider>()
{
provider.Object
};
var targetGraphName = "abc";
var message = await UnresolvedMessages.GetMessageAsync(targetGraphName, range, remoteLibraryProviders, cacheContext.Object, logger, token);
return(message);
}
private LockFile BuildAssetsFile(
LockFile existingLockFile,
PackageSpec project,
IEnumerable <RestoreTargetGraph> graphs,
IReadOnlyList <NuGetv3LocalRepository> localRepositories,
RemoteWalkContext contextForProject)
{
// Build the lock file
var lockFile = new LockFileBuilder(_request.LockFileVersion, _logger, _includeFlagGraphs)
.CreateLockFile(
existingLockFile,
project,
graphs,
localRepositories,
contextForProject);
return(lockFile);
}
private static RemoteWalkContext CreateRemoteWalkContext(RestoreRequest request, RestoreCollectorLogger logger)
{
var context = new RemoteWalkContext(
request.CacheContext,
logger);
foreach (var provider in request.DependencyProviders.LocalProviders)
{
context.LocalLibraryProviders.Add(provider);
}
foreach (var provider in request.DependencyProviders.RemoteProviders)
{
context.RemoteLibraryProviders.Add(provider);
}
return context;
}
public async Task FindPackage_VerifyMissingListedPackageSucceedsOnRetry()
{
// Arrange
var range = new LibraryRange("x", VersionRange.Parse("1.0.0-beta"), LibraryDependencyTarget.Package);
var cacheContext = new SourceCacheContext();
var testLogger = new TestLogger();
var framework = NuGetFramework.Parse("net45");
var context = new RemoteWalkContext(cacheContext, testLogger);
var token = CancellationToken.None;
var edge = new GraphEdge <RemoteResolveResult>(null, null, null);
var actualIdentity = new LibraryIdentity("x", NuGetVersion.Parse("1.0.0-beta"), LibraryType.Package);
var dependencies = new[] { new LibraryDependency()
{
LibraryRange = new LibraryRange("y", VersionRange.All, LibraryDependencyTarget.Package)
} };
var dependencyInfo = LibraryDependencyInfo.Create(actualIdentity, framework, dependencies);
var remoteProvider = new Mock <IRemoteDependencyProvider>();
remoteProvider.Setup(e => e.FindLibraryAsync(range, framework, It.IsAny <SourceCacheContext>(), testLogger, token))
.ReturnsAsync(actualIdentity);
remoteProvider.SetupGet(e => e.IsHttp).Returns(true);
remoteProvider.SetupGet(e => e.Source).Returns(new PackageSource("test"));
var hitCount = 0;
remoteProvider.Setup(e => e.GetDependenciesAsync(actualIdentity, framework, cacheContext, testLogger, token))
.ThrowsAsync(new PackageNotFoundProtocolException(new PackageIdentity(actualIdentity.Name, actualIdentity.Version)))
.Callback(() => ++ hitCount);
remoteProvider.Setup(e => e.GetDependenciesAsync(actualIdentity, framework, It.IsAny <SourceCacheContext>(), testLogger, token))
.ReturnsAsync(dependencyInfo)
.Callback(() => ++ hitCount);
context.RemoteLibraryProviders.Add(remoteProvider.Object);
// Act
var result = await ResolverUtility.FindLibraryEntryAsync(range, framework, null, edge, context, token);
// Assert
Assert.Equal(1, hitCount);
Assert.Equal("x", result.Key.Name);
}
public async Task <GraphNode <RemoteResolveResult> > ResolvePackages(List <PackageId> packages)
{
var walkerContext = new RemoteWalkContext(_cache, _nuGetLogger);
foreach (var sourceRepository in _repositoryProvider.Repositories)
{
var provider = new SourceRepositoryDependencyProvider(sourceRepository, _nuGetLogger, _cache, true, true);
walkerContext.RemoteLibraryProviders.Add(provider);
}
walkerContext.ProjectLibraryProviders.Add(new ProjectLibraryProvider(packages));
var localProvider = new SourceRepositoryDependencyProvider(_localRepository, _nuGetLogger, _cache, true, true);
walkerContext.LocalLibraryProviders.Add(localProvider);
var fakeLib = new LibraryRange("Dropcraft", VersionRange.Parse("1.0.0"), LibraryDependencyTarget.Project);
var walker = new RemoteDependencyWalker(walkerContext);
return(await walker.WalkAsync(fakeLib, _framework, _framework.GetShortFolderName(), RuntimeGraph.Empty, true));
}
public async Task SlowerFeedWinsIfBetterMatchExists()
{
// A
var slowProvider = new TestProvider(TimeSpan.FromSeconds(2));
slowProvider.AddLibrary(new LibraryIdentity
{
Name = "A",
Version = new NuGetVersion("1.0.0")
});
var fastProvider = new TestProvider(TimeSpan.Zero);
fastProvider.AddLibrary(new LibraryIdentity
{
Name = "A",
Version = new NuGetVersion("1.1.0")
});
var context = new RemoteWalkContext();
context.RemoteLibraryProviders.Add(slowProvider);
context.RemoteLibraryProviders.Add(fastProvider);
var walker = new RemoteDependencyWalker(context);
var result = await walker.WalkAsync(new LibraryRange
{
Name = "A",
VersionRange = VersionRange.Parse("1.0.0"),
},
NuGetFramework.Parse("net45"),
runtimeIdentifier: null,
runtimeGraph: null);
Assert.NotNull(result.Item.Data.Match);
Assert.NotNull(result.Item.Data.Match.Library);
Assert.Equal("A", result.Item.Data.Match.Library.Name);
Assert.Equal(new NuGetVersion("1.0.0"), result.Item.Data.Match.Library.Version);
Assert.Equal(slowProvider, result.Item.Data.Match.Provider);
}
