public async Task Packages_from_previous_requests_are_not_returned_in_subsequent_results(Language language)
{
var kernel = CreateBaseKernel(language) as ISupportNuget;
using var restoreContext = new PackageRestoreContext(kernel);
var added = restoreContext.GetOrAddPackageReference("FluentAssertions", "5.7.0");
added.Should().NotBeNull();
var firstResult = await restoreContext.RestoreAsync();
firstResult.ResolvedReferences
.Should()
.Contain(r => r.PackageName == "FluentAssertions");
var readded = restoreContext.GetOrAddPackageReference("FluentAssertions", "5.7.0");
readded.Should().NotBeNull();
var secondResult = await restoreContext.RestoreAsync();
secondResult.ResolvedReferences
.Should()
.NotContain(r => r.PackageName == "FluentAssertions");
}
public async Task Can_get_path_to_nuget_packaged_assembly()
{
using var restoreContext = new PackageRestoreContext();
restoreContext.GetOrAddPackageReference("fluentAssertions", "5.7.0");
await restoreContext.RestoreAsync();
var packageReference = restoreContext.GetResolvedPackageReference("fluentassertions");
var path = packageReference.AssemblyPaths.Single();
// path is a string similar to:
/// c:/users/someuser/.nuget/packages/fluentassertions/5.7.0/netcoreapp2.0/fluentassertions.dll
var dll = new FileInfo(path);
var tfm = dll.Directory.Name;
var reflib = dll.Directory.Parent.Name;
var version = dll.Directory.Parent.Parent.Name;
var packageName = dll.Directory.Parent.Parent.Parent.Name;
dll.Name.ToLower().Should().Be("fluentassertions.dll");
tfm.ToLower().Should().Be("netcoreapp2.0");
reflib.ToLower().Should().Be("lib");
version.ToLower().Should().Be("5.7.0");
packageName.ToLower().Should().Be("fluentassertions");
dll.Exists.Should().BeTrue();
}
public async Task Can_get_path_to_nuget_packaged_assembly(Language language)
{
var kernel = CreateBaseKernel(language) as ISupportNuget;
using var restoreContext = new PackageRestoreContext(kernel);
restoreContext.GetOrAddPackageReference("fluentAssertions", "5.7.0");
await restoreContext.RestoreAsync();
var packageReference = restoreContext.GetResolvedPackageReference("fluentassertions");
var path = packageReference.AssemblyPaths.Single();
// path is a string similar to:
/// c:/users/someuser/.nuget/packages/fluentassertions/5.7.0/netcoreapp2.0/fluentassertions.dll
var name = path.Name;
var tfm = path.Directory.Name;
var reflib = path.Directory.Parent.Name;
var version = path.Directory.Parent.Parent.Name;
var packageName = path.Directory.Parent.Parent.Parent.Name;
name.ToLower().Should().Be("fluentassertions.dll");
tfm.ToLower().Should().Be("netcoreapp2.0");
reflib.ToLower().Should().Be("lib");
version.ToLower().Should().Be("5.7.0");
packageName.ToLower().Should().Be("fluentassertions");
path.Exists.Should().BeTrue();
}
public async Task Fail_if_restore_source_has_an_invalid_uri()
{
using var restoreContext = new PackageRestoreContext();
restoreContext.TryAddRestoreSource("https://completelyFakerestore Source");
var result = await restoreContext.RestoreAsync();
result.Succeeded.Should().BeFalse();
}
private async Task PerformV2Restore(string packagesConfigFilePath, string installPath)
{
var sourceRepositoryProvider = GetSourceRepositoryProvider();
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, Settings, installPath, ExcludeVersion);
var installedPackageReferences = GetInstalledPackageReferences(
packagesConfigFilePath,
allowDuplicatePackageIds: true);
var packageRestoreData = installedPackageReferences.Select(reference =>
new PackageRestoreData(
reference,
new[] { packagesConfigFilePath },
isMissing: true));
var packageSources = GetPackageSources(Settings);
Console.PrintPackageSources(packageSources);
var packageRestoreContext = new PackageRestoreContext(
nuGetPackageManager,
packageRestoreData,
CancellationToken.None,
packageRestoredEvent: null,
packageRestoreFailedEvent: null,
sourceRepositories: packageSources.Select(sourceRepositoryProvider.CreateRepository),
maxNumberOfParallelTasks: DisableParallelProcessing ? 1 : PackageManagementConstants.DefaultMaxDegreeOfParallelism);
var missingPackageReferences = installedPackageReferences.Where(reference =>
!nuGetPackageManager.PackageExistsInPackagesFolder(reference.PackageIdentity)).Any();
if (!missingPackageReferences)
{
var message = string.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("InstallCommandNothingToInstall"),
packagesConfigFilePath);
Console.LogMinimal(message);
}
using (var cacheContext = new SourceCacheContext())
{
cacheContext.NoCache = NoCache;
cacheContext.DirectDownload = DirectDownload;
var downloadContext = new PackageDownloadContext(cacheContext, installPath, DirectDownload);
await PackageRestoreManager.RestoreMissingPackagesAsync(
packageRestoreContext,
new ConsoleProjectContext(Console),
downloadContext);
if (downloadContext.DirectDownload)
{
GetDownloadResultUtility.CleanUpDirectDownloads(downloadContext);
}
}
}
public async Task Returns_failure_if_package_installation_fails()
{
using var restoreContext = new PackageRestoreContext();
var added = restoreContext.GetOrAddPackageReference("not-a-real-package-definitely-not", "5.7.0");
added.Should().NotBeNull();
var result = await restoreContext.RestoreAsync();
result.Succeeded.Should().BeFalse();
result.Errors.Should().NotBeEmpty();
}
public async Task Can_get_path_to_nuget_package()
{
var packageRestoreContext = new PackageRestoreContext();
await packageRestoreContext.AddPackage("fluentAssertions", "5.7.0");
var path = await packageRestoreContext.GetDirectoryForPackage("fluentassertions");
path.FullName.Should().EndWith("fluentassertions" + Path.DirectorySeparatorChar + "5.7.0");
path.Exists.Should().BeTrue();
}
public async Task Can_add_to_list_of_added_sources()
{
using var restoreContext = new PackageRestoreContext();
restoreContext.AddRestoreSource("https://completely FakerestoreSource");
await restoreContext.RestoreAsync();
var restoreSources = restoreContext.RestoreSources;
restoreSources.Should()
.ContainSingle("https://completely FakerestoreSource");
}
public async Task Can_get_path_to_nuget_package_which_doesnt_have_lib_folder()
{
var packageRestoreContext = new PackageRestoreContext();
await packageRestoreContext.AddPackage("roslyn.analyzers", "1.0.3.4");
var path = await packageRestoreContext.GetDirectoryForPackage("roslyn.analyzers");
path.FullName.Should().EndWith("roslyn.analyzers" + Path.DirectorySeparatorChar + "1.0.3.4");
path.Exists.Should().BeTrue();
}
public async Task Disallows_package_specifications_with_with_different_lower_version()
{
using var restoreContext = new PackageRestoreContext();
restoreContext.GetOrAddPackageReference("Microsoft.ML.AutoML", "0.17.0-preview");
restoreContext.GetOrAddPackageReference("Microsoft.ML.AutoML", "0.16.0-preview");
await restoreContext.RestoreAsync();
var resolvedPackageReferences = restoreContext.ResolvedPackageReferences;
resolvedPackageReferences.Should()
.ContainSingle(r => r.PackageName == "Microsoft.ML.AutoML" && r.PackageVersion == "0.17.0-preview");
}
public static CSharpKernel UseNugetDirective(this CSharpKernel kernel)
{
var packageRefArg = new Argument <PackageReference>(
result =>
{
var token = result.Tokens.Select(t => t.Value).SingleOrDefault();
if (PackageReference.TryParse(token, out var reference))
{
return(reference);
}
else
{
result.ErrorMessage = $"Could not parse \"{token}\" as a package reference.";
return(null);
}
})
{
Name = "package"
};
var poundR = new Command("#r")
{
packageRefArg
};
var restoreContext = new PackageRestoreContext();
kernel.RegisterForDisposal(restoreContext);
poundR.Handler = CommandHandler.Create <PackageReference, KernelInvocationContext>(HandleAddPackageReference);
kernel.AddDirective(poundR);
var restore = new Command("#!nuget-restore")
{
Handler = CommandHandler.Create(DoNugetRestore(kernel, restoreContext))
};
kernel.AddDirective(restore);
return(kernel);
async Task HandleAddPackageReference(PackageReference package, KernelInvocationContext pipelineContext)
{
var addPackage = new AddPackage(package)
{
Handler = (command, context) =>
{
if (restoreContext.ResolvedPackageReferences.SingleOrDefault(r => r.PackageName.Equals(package.PackageName, StringComparison.OrdinalIgnoreCase)) is { }
resolvedRef&& !string.IsNullOrWhiteSpace(package.PackageVersion) && package.PackageVersion != resolvedRef.PackageVersion)
{
var errorMessage = $"{GenerateErrorMessage(package, resolvedRef)}";
context.Publish(new ErrorProduced(errorMessage));
}
public async Task Can_get_path_to_nuget_package_when_multiple_packages_are_added()
{
var packageRestoreContext = new PackageRestoreContext();
await packageRestoreContext.AddPackage("fluentAssertions", "5.7.0");
await packageRestoreContext.AddPackage("htmlagilitypack", "1.11.12");
var path = await packageRestoreContext.GetDirectoryForPackage("htmlagilitypack");
path.FullName.Should().EndWith("htmlagilitypack" + Path.DirectorySeparatorChar + "1.11.12");
path.Exists.Should().BeTrue();
}
public async Task Returns_failure_if_package_installation_fails()
{
var restoreContext = new PackageRestoreContext();
var added = restoreContext.AddPackagReference("not-a-real-package-definitely-not", "5.7.0") as bool?;
added.Should().Be(true);
var result = await restoreContext.Restore() as PackageRestoreResult;
result.Succeeded.Should().BeFalse();
result.Errors.Should().NotBeEmpty();
}
public async Task Returns_failure_if_adding_package_twice_at_different_versions()
{
using var restoreContext = new PackageRestoreContext();
var added = restoreContext.GetOrAddPackageReference("another-not-a-real-package-definitely-not", "5.7.0");
added.Should().NotBeNull();
var readded = restoreContext.GetOrAddPackageReference("another-not-a-real-package-definitely-not", "5.7.1");
readded.Should().BeNull();
var result = await restoreContext.RestoreAsync();
result.Succeeded.Should().BeFalse();
result.Errors.Should().NotBeEmpty();
}
private static Command i(PackageRestoreContext restoreContext)
{
var iDirective = new Command("#i")
{
new Argument <string>("source")
};
iDirective.Handler = CommandHandler.Create <string, KernelInvocationContext>((source, context) =>
{
restoreContext.AddRestoreSource(source.Replace("nuget:", ""));
});
return(iDirective);
}
public static CSharpKernel UseNugetDirective(this CSharpKernel kernel)
{
var packageRefArg = new Argument <PackageReference>((SymbolResult result, out PackageReference reference) =>
PackageReference.TryParse(result.Token.Value, out reference))
{
Name = "package"
};
var poundR = new Command("#r")
{
packageRefArg
};
var restoreContext = new PackageRestoreContext();
kernel.RegisterForDisposal(restoreContext);
poundR.Handler = CommandHandler.Create <PackageReference, KernelInvocationContext>(async(package, pipelineContext) =>
{
var addPackage = new AddPackage(package)
{
Handler = async(command, context) =>
{
var added =
await Task.FromResult(
restoreContext.AddPackagReference(
package.PackageName,
package.PackageVersion,
package.RestoreSources));
if (!added)
{
var errorMessage = $"{GenerateErrorMessage(package)}{Environment.NewLine}";
context.Publish(new ErrorProduced(errorMessage));
}
}
};
await pipelineContext.HandlingKernel.SendAsync(addPackage);
});
kernel.AddDirective(poundR);
var restore = new Command("#!nuget-restore")
{
Handler = CommandHandler.Create(DoNugetRestore(kernel, restoreContext))
};
kernel.AddDirective(restore);
return(kernel);
private static Command r(PackageRestoreContext restoreContext)
{
var rDirective = new Command("#r")
{
new Argument <Union <PackageReference, FileInfo> >(
result =>
{
var token = result.Tokens
.Select(t => t.Value)
.SingleOrDefault();
if (PackageReference.TryParse(token, out var reference))
{
return(reference);
}
if (token != null &&
!token.StartsWith("nuget:") &&
!Path.EndsInDirectorySeparator(token))
{
return(new FileInfo(token));
}
result.ErrorMessage = $"Unable to parse package reference: \"{token}\"";
return(null);
})
{
Name = "package"
}
};
rDirective.Handler = CommandHandler.Create <Union <PackageReference, FileInfo>, KernelInvocationContext>(HandleAddPackageReference);
return(rDirective);
Task HandleAddPackageReference(
Union <PackageReference, FileInfo> package,
KernelInvocationContext context)
{
if (package?.Value is PackageReference pkg)
{
var alreadyGotten = restoreContext.ResolvedPackageReferences
.Concat(restoreContext.RequestedPackageReferences)
.FirstOrDefault(r => r.PackageName.Equals(pkg.PackageName, StringComparison.OrdinalIgnoreCase));
if (alreadyGotten is { } && !string.IsNullOrWhiteSpace(pkg.PackageVersion) && pkg.PackageVersion != alreadyGotten.PackageVersion)
{
var errorMessage = $"{GenerateErrorMessage(pkg, alreadyGotten)}";
context.Publish(new ErrorProduced(errorMessage));
}
public async Task Can_get_path_to_nuget_package_root()
{
var packageRestoreContext = new PackageRestoreContext(new CSharpKernel());
await packageRestoreContext.AddPackage("fluentAssertions", "5.7.0");
var packageReference = await packageRestoreContext.GetResolvedNugetPackageReference("fluentassertions");
var path = packageReference.PackageRoot;
path.FullName
.Should()
.EndWith("fluentassertions" + Path.DirectorySeparatorChar + "5.7.0");
path.Exists.Should().BeTrue();
}
public async Task Returns_failure_if_package_installation_fails(Language language)
{
var kernel = CreateBaseKernel(language) as ISupportNuget;
using var restoreContext = new PackageRestoreContext(kernel);
var added = restoreContext.GetOrAddPackageReference("not-a-real-package-definitely-not", "5.7.0");
added.Should().NotBeNull();
var result = await restoreContext.RestoreAsync();
result.Succeeded.Should().BeFalse();
result.Errors.Should().NotBeEmpty();
}
public async Task Can_add_same_source_to_list_of_added_sources_without_error()
{
using var restoreContext = new PackageRestoreContext();
var savedRestoreSources = restoreContext.RestoreSources.ToArray();
restoreContext.AddRestoreSource("https://completely FakerestoreSource");
restoreContext.AddRestoreSource("https://completely FakerestoreSource");
await restoreContext.RestoreAsync();
var restoreSources = restoreContext.RestoreSources.Where(p => !savedRestoreSources.Contains(p));
restoreSources.Should()
.ContainSingle("https://completely FakerestoreSource");
}
public static CSharpKernel UseNugetDirective(this CSharpKernel kernel, INativeAssemblyLoadHelper helper = null)
{
var packageRefArg = new Argument <NugetPackageReference>((SymbolResult result, out NugetPackageReference reference) =>
NugetPackageReference.TryParse(result.Token.Value, out reference))
{
Name = "package"
};
var r = new Command("#r")
{
packageRefArg
};
var restoreContext = new PackageRestoreContext();
r.Handler = CommandHandler.Create <NugetPackageReference, KernelInvocationContext>(async(package, pipelineContext) =>
{
var addPackage = new AddNugetPackage(package)
{
Handler = async context =>
{
var refs = await restoreContext.AddPackage(package.PackageName, package.PackageVersion);
helper?.Configure(await restoreContext.OutputPath());
if (refs != null)
{
foreach (var reference in refs)
{
if (reference is PortableExecutableReference peRef)
{
helper?.Handle(peRef.FilePath);
}
}
kernel.AddMetadataReferences(refs);
}
context.Publish(new NuGetPackageAdded(package));
context.Complete();
}
};
await pipelineContext.HandlingKernel.SendAsync(addPackage);
});
kernel.AddDirective(r);
return(kernel);
}
public async Task Can_get_path_to_nuget_package_root()
{
using var restoreContext = new PackageRestoreContext();
restoreContext.GetOrAddPackageReference("fluentAssertions", "5.7.0");
await restoreContext.RestoreAsync();
var packageReference = restoreContext.GetResolvedPackageReference("fluentassertions");
var path = packageReference.PackageRoot;
path.FullName
.Should()
.EndWith("fluentassertions" + Path.DirectorySeparatorChar + "5.7.0");
path.Exists.Should().BeTrue();
}
private static Command r(PackageRestoreContext restoreContext)
{
var rDirective = new Command("#r")
{
new Argument <PackageReference>(
result =>
{
var token = result.Tokens.Select(t => t.Value).SingleOrDefault();
if (PackageReference.TryParse(token, out var reference))
{
return(reference);
}
else
{
result.ErrorMessage = $"Unable to parse package reference: \"{token}\"";
return(null);
}
})
{
Name = "package"
}
};
rDirective.Handler = CommandHandler.Create <PackageReference, KernelInvocationContext>(HandleAddPackageReference);
return(rDirective);
async Task HandleAddPackageReference(
PackageReference package,
KernelInvocationContext pipelineContext)
{
var addPackage = new AddPackage(package)
{
Handler = (command, context) =>
{
var alreadyGotten =
restoreContext.ResolvedPackageReferences
.Concat(restoreContext.RequestedPackageReferences)
.FirstOrDefault(r => r.PackageName.Equals(package.PackageName, StringComparison.OrdinalIgnoreCase));
if (alreadyGotten is { } &&
!string.IsNullOrWhiteSpace(package.PackageVersion) &&
package.PackageVersion != alreadyGotten.PackageVersion)
{
var errorMessage = $"{GenerateErrorMessage(package, alreadyGotten)}";
context.Publish(new ErrorProduced(errorMessage));
}
public async Task Can_get_path_to_nuget_package_root()
{
using var restoreContext = new PackageRestoreContext();
restoreContext.GetOrAddPackageReference("fluentAssertions", "5.7.0");
await restoreContext.RestoreAsync();
var packageReference = restoreContext.GetResolvedPackageReference("fluentassertions");
var path = packageReference.PackageRoot;
var version = path.Name;
var packageName = path.Parent.Name;
version.ToLower().Should().Be("5.7.0");
packageName.ToLower().Should().Be("fluentassertions");
path.Exists.Should().BeTrue();
}
public async Task Invalid_package_restores_are_not_remembered()
{
using var restoreContext = new PackageRestoreContext();
// This package does not exist
restoreContext.GetOrAddPackageReference("NonExistentNugetPackage", "99.99.99-NoReallyIDontExist");
var setupResult = await restoreContext.RestoreAsync();
setupResult.Succeeded.Should().BeFalse();
// Even though the previous restore failed, this one should succeed
restoreContext.GetOrAddPackageReference("FluentAssertions", "5.7.0");
var result = await restoreContext.RestoreAsync();
result.ResolvedReferences
.Should()
.Contain(r => r.PackageName == "FluentAssertions");
}
public async Task Returns_references_when_package_version_is_not_specified()
{
var restoreContext = new PackageRestoreContext();
var added = restoreContext.AddPackagReference("NewtonSoft.Json") as bool?;
added.Should().Be(true);
var result = await restoreContext.Restore() as PackageRestoreResult;
result.Succeeded.Should().BeTrue();
var assemblyPaths = result.ResolvedReferences.SelectMany(r => r.AssemblyPaths);
assemblyPaths.Should().Contain(r => r.Name.Equals("NewtonSoft.Json.dll", StringComparison.InvariantCultureIgnoreCase));
var packageReference = await restoreContext.GetResolvedPackageReference("NewtonSoft.Json");
packageReference.PackageVersion.Should().NotBeNullOrWhiteSpace();
}
public async Task Can_get_path_to_nuget_packaged_assembly()
{
var packageRestoreContext = new PackageRestoreContext();
await packageRestoreContext.AddPackage("fluentAssertions", "5.7.0");
var packageReference = await packageRestoreContext.GetResolvedNugetPackageReference("fluentassertions");
var path = packageReference.AssemblyPaths.Single();
path.FullName
.ToLower()
.Should()
.EndWith("fluentassertions" + Path.DirectorySeparatorChar +
"5.7.0" + Path.DirectorySeparatorChar +
"lib" + Path.DirectorySeparatorChar +
"netcoreapp2.0" + Path.DirectorySeparatorChar +
"fluentassertions.dll");
path.Exists.Should().BeTrue();
}
public async Task Returns_new_references_if_they_are_added()
{
var restoreContext = new PackageRestoreContext();
var added = restoreContext.AddPackagReference("FluentAssertions", "5.7.0") as bool?;
added.Should().Be(true);
var result = await restoreContext.Restore() as PackageRestoreResult;
result.Errors.Should().BeEmpty();
var assemblyPaths = result.ResolvedReferences.SelectMany(r => r.AssemblyPaths);
assemblyPaths.Should().Contain(r => r.Name.Equals("FluentAssertions.dll"));
assemblyPaths.Should().Contain(r => r.Name.Equals("System.Configuration.ConfigurationManager.dll"));
var packageReference = await restoreContext.GetResolvedPackageReference("fluentassertions");
packageReference.PackageVersion.Should().Be("5.7.0");
}
public async Task Returns_references_when_package_version_is_not_specified()
{
using var restoreContext = new PackageRestoreContext();
var added = restoreContext.GetOrAddPackageReference("NewtonSoft.Json");
added.Should().NotBeNull();
var result = await restoreContext.RestoreAsync();
result.Succeeded.Should().BeTrue();
var assemblyPaths = result.ResolvedReferences.SelectMany(r => r.AssemblyPaths);
assemblyPaths.Should().Contain(r => r.Name.Equals("NewtonSoft.Json.dll", StringComparison.InvariantCultureIgnoreCase));
restoreContext
.ResolvedPackageReferences
.Should()
.Contain(r => r.PackageName.Equals("NewtonSoft.Json", StringComparison.OrdinalIgnoreCase) &&
!string.IsNullOrWhiteSpace(r.PackageVersion));
}
public static CSharpKernel UseNugetDirective(this CSharpKernel kernel)
{
var restoreContext = new PackageRestoreContext();
kernel.SetProperty(restoreContext);
kernel.RegisterForDisposal(restoreContext);
kernel.AddDirective(i(restoreContext));
kernel.AddDirective(r(restoreContext));
var restore = new Command("#!nuget-restore")
{
Handler = CommandHandler.Create(DoNugetRestore(kernel, restoreContext)),
IsHidden = true
};
kernel.AddDirective(restore);
return(kernel);
}
