private void InitPackageUpgradeIssues(FolderNuGetProject folderNuGetProject, NuGetProjectUpgradeDependencyItem package, NuGetFramework framework)
{
_notFoundPackages = new HashSet <PackageIdentity>();
var packageIdentity = new PackageIdentity(package.Id, NuGetVersion.Parse(package.Version));
// Confirm package exists
var packagePath = folderNuGetProject.GetInstalledPackageFilePath(packageIdentity);
if (string.IsNullOrEmpty(packagePath))
{
HasIssues = true;
HasNotFoundPackages = true;
_notFoundPackages.Add(packageIdentity);
package.Issues.Add(PackagingLogMessage.CreateWarning(
string.Format(CultureInfo.CurrentCulture, Resources.Upgrader_PackageNotFound, packageIdentity.Id),
NuGetLogCode.NU5500));
}
else
{
using (var reader = new PackageArchiveReader(packagePath))
{
var packageRules = RuleSet.PackagesConfigToPackageReferenceMigrationRuleSet;
var issues = package.Issues;
foreach (var rule in packageRules)
{
var foundIssues = rule.Validate(reader).OrderBy(p => p.Code.ToString(), StringComparer.CurrentCulture);
if (foundIssues != null && foundIssues.Any())
{
HasIssues = true;
}
issues.AddRange(foundIssues);
}
}
}
}
public async void installPackagesFromProvidedAppSettingsFileAsync()
{
var serachResult = await _packageSearcher.GetSinglePackageMetaDataAsync();
var identity = serachResult.Identity;
var rootPath = @"myPathToTheFolder";
ISettings settings = Settings.LoadDefaultSettings(rootPath, null, new MachineWideSettings());
PackageSourceProvider packageSourceProvider = new PackageSourceProvider(settings);
ISourceRepositoryProvider sourceRepositoryProvider =
new SourceRepositoryProvider(packageSourceProvider, GetV3AndV2Providers());
var project = new FolderNuGetProject(rootPath);
string packagesPath = "...";
NuGetPackageManager packageManager = new NuGetPackageManager(sourceRepositoryProvider, settings, packagesPath)
{
PackagesFolderNuGetProject = project
};
bool allowPrereleaseVersions = true;
bool allowUnlisted = false;
ResolutionContext resolutionContext = new ResolutionContext(
DependencyBehavior.Lowest, allowPrereleaseVersions, allowUnlisted, VersionConstraints.None);
INuGetProjectContext projectContext = new DefaultProjectContext();
IEnumerable <SourceRepository> sourceRepositories = Enumerable.Repeat(_packageSearcher.GetSourceRepository(), 1);
await packageManager.InstallPackageAsync(packageManager.PackagesFolderNuGetProject,
identity, resolutionContext, projectContext, sourceRepositories,
Array.Empty <SourceRepository>(),
CancellationToken.None);
}
public NuGetDownloader(TargetFramework targetFramework, string?outputDir = null,
bool includePrerelease = false, bool recursive = false, bool extract = true,
IEnumerable <string>?sources = null)
: base(sources)
{
TargetFramework = targetFramework;
Recursive = recursive;
Extract = extract;
IncludePrerelease = includePrerelease;
outputDir ??= Directory.GetCurrentDirectory();
(_downloadDir, _extractDir) = extract
? (Path.Combine(Path.GetTempPath(), $"NuGetPackageDownloader.{Guid.NewGuid():N}"), outputDir)
: (outputDir, null);
_framework = targetFramework.ToNuGetFramework();
_project = new FolderNuGetProject(_downloadDir);
var packageSourceProvider = new PackageSourceProvider(Settings);
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, ResourceProviders);
_packageManager = new NuGetPackageManager(sourceRepositoryProvider, Settings, _downloadDir)
{
PackagesFolderNuGetProject = _project,
};
}
public async override Task ExecuteCommand()
{
CalculateEffectivePackageSaveMode();
string installPath = ResolveInstallPath();
var packageSourceProvider = new NuGet.Configuration.PackageSourceProvider(Settings);
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, ResourceProviders);
IEnumerable <SourceRepository> primarySources;
IEnumerable <SourceRepository> secondarySources;
GetEffectiveSources(sourceRepositoryProvider, out primarySources, out secondarySources);
if (Arguments.Count == 0)
{
throw new InvalidOperationException(NuGetResources.InstallCommandPackageIdMustBeProvided);
}
string packageId = Arguments[0];
NuGetPackageManager packageManager = new NuGetPackageManager(sourceRepositoryProvider, installPath);
ResolutionContext resolutionContext = new ResolutionContext(dependencyBehavior: DependencyBehavior, includePrelease: Prerelease);
FolderNuGetProject nugetProject = new FolderNuGetProject(installPath);
nugetProject.PackageSaveMode = EffectivePackageSaveMode;
if (Version == null)
{
await packageManager.InstallPackageAsync(nugetProject, packageId, resolutionContext, new Common.Console(),
primarySources, secondarySources, CancellationToken.None);
}
else
{
await packageManager.InstallPackageAsync(nugetProject, new PackageIdentity(packageId, new NuGetVersion(Version)), resolutionContext,
new Common.Console(), primarySources, secondarySources, CancellationToken.None);
}
}
/// <summary>
/// Installs application package.
/// </summary>
/// <remarks>
/// На текущий момент это вся документация по использованию библиотек Nuget:
/// https://daveaglick.com/posts/exploring-the-nuget-v3-libraries-part-1
/// https://daveaglick.com/posts/exploring-the-nuget-v3-libraries-part-2
/// https://daveaglick.com/posts/exploring-the-nuget-v3-libraries-part-3
/// </remarks>
/// <returns></returns>
public async Task Install(AppInfo appInfo)
{
var sourceRepository = new SourceRepository(_nugetSettings.PackageSource.Value, _nugetSettings.ResourceProviders);
var sourceRepositoryProvider = new SourceRepositoryProvider(_nugetSettings.Configuration.Value, _nugetSettings.ResourceProviders);
var project = new FolderNuGetProject(_appSettings.InstallDirectoryPath);
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, _nugetSettings.Configuration.Value, PackagesFolderPath)
{
PackagesFolderNuGetProject = project
};
var resolutionContext = new ResolutionContext(DependencyBehavior.Lowest, true, false, VersionConstraints.None);
var emptyNuGetProjectContext = new EmptyNuGetProjectContext();
var sourceRepositories = Array.Empty <SourceRepository>();
await nuGetPackageManager.InstallPackageAsync(project, new PackageIdentity(appInfo.PackageId, NuGetVersion.Parse(appInfo.Version)), resolutionContext, emptyNuGetProjectContext, sourceRepository, sourceRepositories, CancellationToken.None);
if (appInfo.HasInstance())
{
var directoryName = Path.Combine(_appSettings.InstallDirectoryPath, $"{appInfo.PackageId}.{appInfo.Version}");
var directoryForInstanceName = Path.Combine(_appSettings.InstallDirectoryPath, appInfo.ToString());
var directoryInfo = new DirectoryInfo(directoryName);
if (directoryInfo.Exists && !Directory.Exists(directoryForInstanceName))
{
directoryInfo.MoveTo(directoryForInstanceName);
}
}
}
public async Task InstallPackageAsync_InstallsPackage()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
using (var randomTestSourcePath = TestDirectory.Create())
using (var randomTestDestinationPath = TestDirectory.Create())
{
var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage(
randomTestSourcePath,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString());
var folderNuGetProject = new FolderNuGetProject(randomTestDestinationPath);
var packagePathResolver = new PackagePathResolver(randomTestDestinationPath);
var packageInstallPath = packagePathResolver.GetInstallPath(packageIdentity);
var nupkgFilePath = Path.Combine(packageInstallPath, packagePathResolver.GetPackageFileName(packageIdentity));
var testNuGetProjectContext = new TestNuGetProjectContext();
var token = CancellationToken.None;
using (var packageStream = GetDownloadResourceResult(packageFileInfo))
{
// Act
await folderNuGetProject.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token);
}
// Assert
Assert.True(File.Exists(nupkgFilePath));
Assert.True(File.Exists(Path.Combine(packageInstallPath, "lib/test.dll")));
using (var packageStream = File.OpenRead(nupkgFilePath))
{
var zipArchive = new ZipArchive(packageStream);
Assert.Equal(5, zipArchive.Entries.Count);
}
}
}
/// <summary>Returns the referenced .dll/.exe file paths</summary>
public IEnumerable <FilePath> GetReferencedAssembliesFilePaths(FolderNuGetProject project,
NuGetFramework targetFramework)
{
var pkgPath = GetPackageDirectoryPath(project);
var archiveReader = GetArchiveReader(project);
List <FrameworkSpecificGroup> referenceItems = archiveReader.GetReferenceItems().ToList();
FrameworkSpecificGroup referenceGroup = SelectFrameworkMostCompatibleGroup(targetFramework, referenceItems);
if (referenceGroup != null)
{
LogTo.Verbose(
$"Found compatible reference group {referenceGroup.TargetFramework.DotNetFrameworkName} for package {Identity}");
foreach (FilePath assemblyPath in referenceGroup.Items
.Select(x => new FilePath(x))
.Where(x => x.Extension == ".dll" || x.Extension == ".exe")
.Select(pkgPath.CombineFile))
{
LogTo.Verbose($"Found NuGet reference {assemblyPath} from package {Identity}");
yield return(assemblyPath);
}
}
else if (referenceItems.Count == 0)
{
// Only show a verbose message if there were no reference items (I.e., it's probably a content-only package or a metapackage and not a mismatch)
LogTo.Verbose($"Could not find any reference items in package {Identity}");
}
else
{
LogTo.Verbose(
$"Could not find compatible reference group for package {Identity} (found {string.Join(",", referenceItems.Select(x => x.TargetFramework.DotNetFrameworkName))})");
}
}
public async Task PackagePreFetcher_NoActionsInput()
{
using (var packagesFolderDir = TestDirectory.Create())
using (var globalPackagesFolder = TestDirectory.Create())
{
// Arrange
var actions = new List <NuGetProjectAction>();
var packagesFolder = new FolderNuGetProject(packagesFolderDir);
var testSettings = new Configuration.NullSettings();
var logger = new TestLogger();
// Act
using (var cacheContext = new SourceCacheContext())
{
var result = await PackagePreFetcher.GetPackagesAsync(
actions,
packagesFolder,
new PackageDownloadContext(cacheContext),
globalPackagesFolder,
logger,
CancellationToken.None);
// Assert
Assert.Equal(0, result.Count);
}
}
}
public async Task PackagePreFetcher_NoInstallActionsInput()
{
using (var packagesFolderDir = TestFileSystemUtility.CreateRandomTestFolder())
{
// Arrange
var actions = new List <NuGetProjectAction>();
var packagesFolder = new FolderNuGetProject(packagesFolderDir);
var testSettings = new Configuration.NullSettings();
var logger = new TestLogger();
var target = new PackageIdentity("packageA", NuGetVersion.Parse("1.0.0"));
var target2 = new PackageIdentity("packageB", NuGetVersion.Parse("1.0.0"));
actions.Add(NuGetProjectAction.CreateUninstallProjectAction(target));
actions.Add(NuGetProjectAction.CreateUninstallProjectAction(target2));
// Act
var result = await PackagePreFetcher.GetPackagesAsync(
actions,
packagesFolder,
testSettings,
logger,
CancellationToken.None);
// Assert
Assert.Equal(0, result.Count);
}
}
public async Task PackagePreFetcher_NoInstallActionsInput()
{
using (var packagesFolderDir = TestDirectory.Create())
using (var globalPackagesFolder = TestDirectory.Create())
{
// Arrange
var actions = new List <NuGetProjectAction>();
var packagesFolder = new FolderNuGetProject(packagesFolderDir);
var testSettings = new Configuration.NullSettings();
var logger = new TestLogger();
var target = new PackageIdentity("packageA", NuGetVersion.Parse("1.0.0"));
var target2 = new PackageIdentity("packageB", NuGetVersion.Parse("1.0.0"));
actions.Add(NuGetProjectAction.CreateUninstallProjectAction(target, packagesFolder));
actions.Add(NuGetProjectAction.CreateUninstallProjectAction(target2, packagesFolder));
// Act
using (var cacheContext = new SourceCacheContext())
{
var result = await PackagePreFetcher.GetPackagesAsync(
actions,
packagesFolder,
new PackageDownloadContext(cacheContext),
globalPackagesFolder,
logger,
CancellationToken.None);
// Assert
Assert.Equal(0, result.Count);
}
}
}
public void PackageExists_PackageIdentity_ThrowsForNullPackageIdentity()
{
var project = new FolderNuGetProject(root: "a");
var exception = Assert.Throws <ArgumentNullException>(() => project.PackageExists(packageIdentity: null));
Assert.Equal("packageIdentity", exception.ParamName);
}
public void Constructor_StringPackagePathResolver_InitializesRootProperty()
{
var project = new FolderNuGetProject(
root: "a",
packagePathResolver: new PackagePathResolver(rootDirectory: "a"));
Assert.Equal("a", project.Root);
}
public async Task GetInstalledPackagesAsync_ReturnsEmptyEnumerable()
{
var project = new FolderNuGetProject(root: "a");
var packages = await project.GetInstalledPackagesAsync(CancellationToken.None);
Assert.Empty(packages);
}
/// <summary>
/// No solution manager provided so only global packages cache will be considered.
/// </summary>
public PackageManagementPathResolver()
{
var settings = SettingsLoader.LoadDefaultSettings();
var pathContext = NuGetPathContext.Create(settings);
pathResolver = new FallbackPackagePathResolver(pathContext);
globalPackagesFolderResolver = new VersionFolderPathResolver(pathContext.UserPackageFolder);
folderNuGetProject = new FolderNuGetProject(pathContext.UserPackageFolder);
}
public PackageManagementPathResolver(IMonoDevelopSolutionManager solutionManager)
{
var pathContext = NuGetPathContext.Create(solutionManager.Settings);
pathResolver = new FallbackPackagePathResolver(pathContext);
globalPackagesFolderResolver = new VersionFolderPathResolver(pathContext.UserPackageFolder);
string packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(solutionManager, solutionManager.Settings);
folderNuGetProject = new FolderNuGetProject(packagesFolderPath);
}
private static PackageArchiveReader GetArchiveReader(this NuGetPackage pkg, FolderNuGetProject project)
{
var pkgPath = pkg.GetPackageFilePath(project)?.FullPath;
if (pkgPath == null)
{
return(null);
}
return(new PackageArchiveReader(pkgPath, null, null));
}
public async Task UninstallPackageAsync_DoesNothing()
{
var project = new FolderNuGetProject(root: "a");
var wasUninstalled = await project.UninstallPackageAsync(
new PackageIdentity(id : "a", version : NuGetVersion.Parse("1.0.0")),
new Mock <INuGetProjectContext>(MockBehavior.Strict).Object,
CancellationToken.None);
Assert.True(wasUninstalled);
}
public async Task InstallPackageAsync_WithSourceControlDisabled()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
using (var randomTestSourcePath = TestDirectory.Create())
using (var randomTestDestinationPath = TestDirectory.Create())
{
var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage(
randomTestSourcePath,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString());
// Create a nuget.config file with source control disabled
File.WriteAllText(
Path.Combine(randomTestSourcePath, "nuget.config"),
@"<?xml version=""1.0"" encoding=""utf-8""?>
<configuration>
<solution>
<add key=""disableSourceControlIntegration"" value=""true"" />
</solution >
</configuration>");
var settings = new Settings(randomTestSourcePath);
var folderNuGetProject = new FolderNuGetProject(randomTestDestinationPath);
var packagePathResolver = new PackagePathResolver(randomTestDestinationPath);
var packageInstallPath = packagePathResolver.GetInstallPath(packageIdentity);
var nupkgFilePath
= Path.Combine(packageInstallPath, packagePathResolver.GetPackageFileName(packageIdentity));
var testSourceControlManager = new TestSourceControlManager(settings);
var testNuGetProjectContext = new TestNuGetProjectContext()
{
SourceControlManagerProvider = new TestSourceControlManagerProvider(testSourceControlManager)
};
var token = CancellationToken.None;
using (var packageStream = GetDownloadResourceResult(packageFileInfo))
{
// Act
await folderNuGetProject.InstallPackageAsync(
packageIdentity,
packageStream,
testNuGetProjectContext,
token);
}
// Assert
Assert.True(File.Exists(nupkgFilePath));
Assert.Equal(0, testSourceControlManager.PendAddedFiles.Count);
}
}
public async Task InstallPackageAsync_WithSourceControlEnabled()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
using (var randomTestSourcePath = TestDirectory.Create())
using (var randomTestDestinationPath = TestDirectory.Create())
{
var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage(
randomTestSourcePath,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString());
var folderNuGetProject = new FolderNuGetProject(randomTestDestinationPath);
var packagePathResolver = new PackagePathResolver(randomTestDestinationPath);
var packageInstallPath = packagePathResolver.GetInstallPath(packageIdentity);
var nupkgFilePath
= Path.Combine(packageInstallPath, packagePathResolver.GetPackageFileName(packageIdentity));
var testSourceControlManager = new TestSourceControlManager();
var testNuGetProjectContext = new TestNuGetProjectContext()
{
SourceControlManagerProvider = new TestSourceControlManagerProvider(testSourceControlManager)
};
var token = CancellationToken.None;
using (var packageStream = GetDownloadResourceResult(packageFileInfo))
{
// Act
await folderNuGetProject.InstallPackageAsync(
packageIdentity,
packageStream,
testNuGetProjectContext,
token);
}
// Assert
Assert.True(File.Exists(nupkgFilePath));
Assert.Equal(5, testSourceControlManager.PendAddedFiles.Count);
Assert.True(testSourceControlManager.PendAddedFiles.Contains(nupkgFilePath));
var expectedEntries = new[]
{
"lib/test.dll",
"lib/net40/test40.dll",
"lib/net40/test40b.dll",
"lib/net45/test45.dll"
};
Assert.All(
expectedEntries.Select(e => Path.Combine(packageInstallPath, e.Replace('/', Path.DirectorySeparatorChar))),
item => Assert.Contains(item, testSourceControlManager.PendAddedFiles));
}
}
public string GetPackagePathInOutputDirectory(PackageIdentity identity)
{
var project = new FolderNuGetProject(OutputPackagesPath);
var path = project.GetInstalledPath(identity);
if (string.IsNullOrEmpty(path))
{
return(null);
}
return(path);
}
public async Task DeletePackage_DeletesPackage()
{
// Arrange
using (var randomTestSourcePath = TestDirectory.Create())
using (var randomTestDestinationPath = TestDirectory.Create())
{
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyContentPackage(
randomTestSourcePath,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString());
var folderNuGetProject = new FolderNuGetProject(randomTestDestinationPath);
var packagePathResolver = new PackagePathResolver(randomTestDestinationPath);
var packageInstallPath = packagePathResolver.GetInstallPath(packageIdentity);
var nupkgFilePath = Path.Combine(packageInstallPath, packagePathResolver.GetPackageFileName(packageIdentity));
var testNuGetProjectContext = new TestNuGetProjectContext();
var token = CancellationToken.None;
using (var packageStream = GetDownloadResourceResult(packageFileInfo))
{
// Act
await folderNuGetProject.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token);
}
var unNormalizedPackageIdentity = new PackageIdentity(packageIdentity.Id,
new NuGetVersion(packageIdentity.Version + ".0"));
// Assert
Assert.True(File.Exists(nupkgFilePath));
Assert.True(File.Exists(Path.Combine(packageInstallPath, "Content/Scripts/test1.js")));
using (var packageStream = File.OpenRead(nupkgFilePath))
{
var zipArchive = new ZipArchive(packageStream);
Assert.Equal(6, zipArchive.Entries.Count);
}
Assert.True(folderNuGetProject.PackageExists(packageIdentity));
var packageDirectoryPath = folderNuGetProject.GetInstalledPath(unNormalizedPackageIdentity);
Assert.True(!string.IsNullOrEmpty(packageDirectoryPath));
Assert.True(Directory.Exists(packageDirectoryPath));
// Main Act
await folderNuGetProject.DeletePackage(packageIdentity, testNuGetProjectContext, CancellationToken.None);
// Assert
Assert.False(folderNuGetProject.PackageExists(unNormalizedPackageIdentity));
// Check that the package directories are deleted
Assert.False(Directory.Exists(packageDirectoryPath));
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="packageSource">package source</param>
/// <param name="destinationPath">destination path where the packages should be downloaded</param>
internal NuGetPackageDownloader(string packageSource, string destinationPath)
{
_logger = new Logger();
_providers = new List <Lazy <INuGetResourceProvider> >();
_providers.AddRange(Repository.Provider.GetCoreV3());
_packageSource = new PackageSource(packageSource);
_sourceRepository = new SourceRepository(_packageSource, _providers);
_searchResource = _sourceRepository.GetResource <PackageSearchResource>();
_settings = Settings.LoadDefaultSettings(destinationPath);
_project = new FolderNuGetProject(destinationPath);
_packageManager = new NuGetPackageManager(new SourceRepositoryProvider(new PackageSourceProvider(_settings), _providers), _settings, destinationPath);
_projectContext = new ProjectContext(_logger);
_searchFilter = new SearchFilter(true, SearchFilterType.IsAbsoluteLatestVersion);
_resolutionContext = new ResolutionContext(NuGet.Resolver.DependencyBehavior.Ignore, false, false, VersionConstraints.None);
_secondarySources = new List <SourceRepository>();
}
public async Task PackagePreFetcher_PackageAlreadyExistsReinstall()
{
using (var sourceDir = TestDirectory.Create())
using (var packagesFolderDir = TestDirectory.Create())
using (var globalPackagesFolder = TestDirectory.Create())
{
// Arrange
var actions = new List <NuGetProjectAction>();
var packagesFolder = new FolderNuGetProject(packagesFolderDir);
var testSettings = NullSettings.Instance;
var logger = new TestLogger();
var target = new PackageIdentity("packageA", NuGetVersion.Parse("1.0.0"));
var source = Repository.Factory.GetVisualStudio(new Configuration.PackageSource(sourceDir.Path));
// Add package
AddToPackagesFolder(target, packagesFolderDir);
actions.Add(NuGetProjectAction.CreateUninstallProjectAction(target, packagesFolder));
actions.Add(NuGetProjectAction.CreateInstallProjectAction(target, source, packagesFolder));
AddToSource(target, sourceDir);
// Act
using (var cacheContext = new SourceCacheContext())
{
var result = await PackagePreFetcher.GetPackagesAsync(
actions,
packagesFolder,
new PackageDownloadContext(cacheContext),
globalPackagesFolder,
logger,
CancellationToken.None);
using (var downloadResult = await result[target].GetResultAsync())
{
// Assert
Assert.Equal(1, result.Count);
Assert.False(result[target].InPackagesFolder);
Assert.Equal(source.PackageSource, result[target].Source);
Assert.Equal(target, result[target].Package);
Assert.True(result[target].IsComplete);
Assert.Equal(target, downloadResult.PackageReader.GetIdentity());
Assert.NotNull(downloadResult.PackageStream);
Assert.Equal(DownloadResourceResultStatus.Available, downloadResult.Status);
}
}
}
}
public async Task PackagePreFetcher_PackageDoesNotExistAnywhere()
{
using (var sourceDir = TestDirectory.Create())
using (var packagesFolderDir = TestDirectory.Create())
using (var globalPackagesFolder = TestDirectory.Create())
{
// Arrange
var actions = new List <NuGetProjectAction>();
var packagesFolder = new FolderNuGetProject(packagesFolderDir);
var testSettings = NullSettings.Instance;
var logger = new TestLogger();
var target = new PackageIdentity("packageA", NuGetVersion.Parse("1.0.0"));
var source = Repository.Factory.GetVisualStudio(new Configuration.PackageSource(sourceDir.Path));
actions.Add(NuGetProjectAction.CreateInstallProjectAction(target, source, packagesFolder));
// Act
using (var cacheContext = new SourceCacheContext())
{
var result = await PackagePreFetcher.GetPackagesAsync(
actions,
packagesFolder,
new PackageDownloadContext(cacheContext),
globalPackagesFolder,
logger,
CancellationToken.None);
Exception exception = null;
try
{
using (await result[target].GetResultAsync())
{
}
Assert.True(false);
}
catch (Exception ex)
{
exception = ex;
}
// Assert
Assert.StartsWith("Package 'packageA.1.0.0' is not found on source", exception.Message);
}
}
}
internal FolderNuGetProjectTest(bool useSideBySidePaths = true)
{
PackageIdentity = new PackageIdentity(id: "a", version: NuGetVersion.Parse("1.0.0"));
TestDirectory = TestDirectory.Create();
ProjectDirectory = Directory.CreateDirectory(Path.Combine(TestDirectory.Path, "project"));
Resolver = new PackagePathResolver(ProjectDirectory.FullName, useSideBySidePaths);
Project = new FolderNuGetProject(ProjectDirectory.FullName, Resolver);
var sourcePackageDirectoryPath = Path.Combine(TestDirectory.Path, "source");
Directory.CreateDirectory(sourcePackageDirectoryPath);
Package = TestPackagesGroupedByFolder.GetLegacyTestPackage(
sourcePackageDirectoryPath,
PackageIdentity.Id,
PackageIdentity.Version.ToNormalizedString());
}
public void TryGetMetadata_GetsProjectMetadata()
{
// Arrange
using (var randomTestFolder = TestDirectory.Create())
{
var folderNuGetProject = new FolderNuGetProject(randomTestFolder);
// Act & Assert
NuGetFramework targetFramework;
Assert.True(folderNuGetProject.TryGetMetadata(NuGetProjectMetadataKeys.TargetFramework, out targetFramework));
string name;
Assert.True(folderNuGetProject.TryGetMetadata(NuGetProjectMetadataKeys.Name, out name));
Assert.Equal(NuGetFramework.AnyFramework, targetFramework);
Assert.Equal(randomTestFolder, name);
Assert.Equal(2, folderNuGetProject.Metadata.Count);
}
}
protected void CreateInitNuGetProject()
{
var solutionManager = PackageManagementServices.Workspace.GetSolutionManager(project.ParentSolution);
nugetProject = solutionManager.GetNuGetProject(project);
if (nugetProject is INuGetIntegratedProject)
{
PackagesFolderPath = SettingsUtility.GetGlobalPackagesFolder(solutionManager.Settings);
packagePathResolver = new VersionFolderPathResolver(
PackagesFolderPath);
}
else
{
PackagesFolderPath = nugetProject.GetPackagesFolderPath(solutionManager);
folder = new FolderNuGetProject(PackagesFolderPath);
}
}
private static async Task InstallPackage(PackageIdentity packageIdentity, string packageRoot, NuGetFramework framework)
{
var packagesPath = Path.Combine(packageRoot, "packages");
var settings = Settings.LoadDefaultSettings(packageRoot, null, new XPlatMachineWideSetting());
var sourceRepositoryProvider = new SourceRepositoryProvider(settings);
var folder = new FolderNuGetProject(packageRoot, new PackagePathResolver(packageRoot), framework ?? FrameworkConstants.CommonFrameworks.NetStandard20);
var packageManager = new NuGetPackageManager(sourceRepositoryProvider, settings, packagesPath)
{
PackagesFolderNuGetProject = folder
};
var resolutionContext = new ResolutionContext(
DependencyBehavior.Lowest,
includePrelease: false,
includeUnlisted: false,
VersionConstraints.None);
var projectContext = new NuGetProjectContext(settings);
var retryPolicy = Policy
.Handle <Exception>()
.WaitAndRetryAsync(
5,
retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
(exception, _, __) =>
{
Log.Warning(
"An exception was thrown whilst retrieving or installing {0}: {1}",
packageIdentity,
exception);
});
await retryPolicy.ExecuteAsync(async() =>
{
await packageManager.InstallPackageAsync(
packageManager.PackagesFolderNuGetProject,
packageIdentity,
resolutionContext,
projectContext,
sourceRepositoryProvider.GetDefaultRepositories(),
Array.Empty <SourceRepository>(),
CancellationToken.None).ConfigureAwait(false);
}).ConfigureAwait(false);
}
private void ExtractPackageAssemblies(IEnumerable <PackageIdentity> identities)
{
if (!Extract)
{
return;
}
var project = new FolderNuGetProject(_downloadDir);
if (!Directory.Exists(_extractDir))
{
Directory.CreateDirectory(_extractDir);
}
foreach (PackageIdentity identity in identities)
{
string packageFilePath = project.GetInstalledPackageFilePath(identity);
if (string.IsNullOrWhiteSpace(packageFilePath))
{
continue;
}
FrameworkSpecificGroup?referenceGroup;
using (var archiveReader = new PackageArchiveReader(packageFilePath, null, null))
referenceGroup = GetMostCompatibleGroup(_framework, archiveReader.GetReferenceItems());
if (referenceGroup is null || referenceGroup.Items is null || !referenceGroup.Items.Any())
{
continue;
}
string nugetPackagePath = project.GetInstalledPath(identity);
Parallel.ForEach(referenceGroup.Items, x =>
{
string sourceAssemblyPath = Path.Combine(nugetPackagePath, x);
string assemblyName = Path.GetFileName(sourceAssemblyPath);
string destinationAssemblyPath = Path.Combine(_extractDir, assemblyName);
File.Copy(sourceAssemblyPath, destinationAssemblyPath, true);
});
}
}
public void TestFolderNuGetProjectMetadata()
{
// Arrange
var randomTestFolder = TestFilesystemUtility.CreateRandomTestFolder();
var folderNuGetProject = new FolderNuGetProject(randomTestFolder);
// Act & Assert
NuGetFramework targetFramework;
Assert.True(folderNuGetProject.TryGetMetadata <NuGetFramework>(NuGetProjectMetadataKeys.TargetFramework, out targetFramework));
string name;
Assert.True(folderNuGetProject.TryGetMetadata <string>(NuGetProjectMetadataKeys.Name, out name));
Assert.Equal(NuGetFramework.AnyFramework, targetFramework);
Assert.Equal(randomTestFolder, name);
Assert.Equal(2, folderNuGetProject.Metadata.Count);
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(randomTestFolder);
}
