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);
}
}
public VisualStudioUIContext(
NuGetPackage package,
ISourceRepositoryProvider sourceProvider,
ISolutionManager solutionManager,
NuGetPackageManager packageManager,
UIActionEngine uiActionEngine,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IEnumerable<NuGet.ProjectManagement.NuGetProject> projects) :
base(sourceProvider, solutionManager, packageManager, uiActionEngine, packageRestoreManager, optionsPageActivator, projects)
{
_package = package;
}
public static Task AcceptLicenses (
IEnumerable<SourceRepository> sources,
IEnumerable<NuGetProjectAction> actions,
NuGetPackageManager packageManager,
CancellationToken cancellationToken)
{
return AcceptLicenses (
sources,
actions,
new MonoDevelopNuGetPackageManager (packageManager),
new LicenseAcceptanceService (),
cancellationToken);
}
public MonoDevelopNuGetPackageManager (IMonoDevelopSolutionManager solutionManager)
{
var restartManager = new DeleteOnRestartManager ();
settings = solutionManager.Settings;
packageManager = new NuGetPackageManager (
solutionManager.CreateSourceRepositoryProvider (),
settings,
solutionManager,
restartManager
);
}
public StandaloneUIContext(
string settingsFile,
ISourceRepositoryProvider sourceProvider,
ISolutionManager solutionManager,
NuGetPackageManager packageManager,
UIActionEngine uiActionEngine,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IEnumerable<NuGet.ProjectManagement.NuGetProject> projects) :
base(sourceProvider, solutionManager, packageManager, uiActionEngine, packageRestoreManager, optionsPageActivator, projects)
{
_settingsFile = settingsFile;
LoadSettings();
}
public INuGetUIContext Create(string settingsFile, IEnumerable<NuGetProject> projects)
{
if (String.IsNullOrEmpty(settingsFile))
{
throw new ArgumentException("settingsFile");
}
if (projects == null || !projects.Any())
{
throw new ArgumentNullException("projects");
}
NuGetPackageManager packageManager = new NuGetPackageManager(_repositoryProvider, _settings, _solutionManager);
UIActionEngine actionEngine = new UIActionEngine(_repositoryProvider, packageManager);
return new StandaloneUIContext(settingsFile, _repositoryProvider, _solutionManager, packageManager, actionEngine, _restoreManager, _optionsPage, projects);
}
public async Task TestPackageRestoredEvent()
{
// Arrange
var testSolutionManager = new TestSolutionManager();
var projectA = testSolutionManager.AddNewMSBuildProject();
var projectB = testSolutionManager.AddNewMSBuildProject();
var packageIdentity = Packages[0];
var testNuGetProjectContext = new TestNuGetProjectContext();
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var testSettings = NullSettings.Instance;
var resolutionContext = new ResolutionContext();
var token = CancellationToken.None;
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager);
await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity,
resolutionContext, new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token);
await nuGetPackageManager.InstallPackageAsync(projectB, packageIdentity,
resolutionContext, new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token);
var packageRestoreManager = new PackageRestoreManager(sourceRepositoryProvider, testSettings, testSolutionManager);
var restoredPackages = new List<PackageIdentity>();
packageRestoreManager.PackageRestoredEvent += delegate(object sender, PackageRestoredEventArgs args)
{
if(args.Restored)
{
restoredPackages.Add(args.Package);
}
};
Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder(packageIdentity));
// Delete packages folder
Directory.Delete(Path.Combine(testSolutionManager.SolutionDirectory, "packages"), recursive: true);
Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity)));
// Act
await packageRestoreManager.RestoreMissingPackagesInSolutionAsync(CancellationToken.None);
Assert.Equal(1, restoredPackages.Count);
Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity)));
}
public async Task TestPacManInstallPackage()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var testSolutionManager = new TestSolutionManager();
var testSettings = new NullSettings();
var token = CancellationToken.None;
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var randomPackagesConfigFolderPath = TestFilesystemUtility.CreateRandomTestFolder();
var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config");
var projectTargetFramework = NuGetFramework.Parse("net45");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigPath);
var packageIdentity = NoDependencyLibPackages[0];
// Pre-Assert
// Check that the packages.config file does not exist
Assert.False(File.Exists(randomPackagesConfigPath));
// Check that there are no packages returned by PackagesConfigProject
var packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(0, packagesInPackagesConfig.Count);
Assert.Equal(0, msBuildNuGetProjectSystem.References.Count);
// Act
await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, packageIdentity,
new ResolutionContext(), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
// Check that the packages.config file exists after the installation
Assert.True(File.Exists(randomPackagesConfigPath));
// Check the number of packages and packages returned by PackagesConfigProject after the installation
packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(1, packagesInPackagesConfig.Count);
Assert.Equal(packageIdentity, packagesInPackagesConfig[0].PackageIdentity);
Assert.Equal(projectTargetFramework, packagesInPackagesConfig[0].TargetFramework);
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory, randomPackagesConfigFolderPath);
}
public INuGetUIContext Create(NuGetPackage package, IEnumerable<NuGet.ProjectManagement.NuGetProject> projects)
{
if (projects == null || !projects.Any())
{
throw new ArgumentNullException("projects");
}
NuGetPackageManager packageManager = new NuGetPackageManager(_repositoryProvider, _settings, _solutionManager);
UIActionEngine actionEngine = new UIActionEngine(_repositoryProvider, packageManager);
return new VisualStudioUIContext(
package,
_repositoryProvider,
_solutionManager,
packageManager,
actionEngine,
_restoreManager,
_optionsPage,
projects);
}
public void UninstallPackage(Project project, string packageId, bool removeDependencies)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
if (String.IsNullOrEmpty(packageId))
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "packageId"));
}
NuGetPackageManager packageManager = new NuGetPackageManager(_sourceRepositoryProvider, _settings, _solutionManager);
UninstallationContext uninstallContext = new UninstallationContext(removeDependencies, false);
VSAPIProjectContext projectContext = new VSAPIProjectContext();
// find the project
NuGetProject nuGetProject = PackageManagementHelpers.GetProject(_solutionManager, project, projectContext);
// uninstall the package
PackageManagementHelpers.RunSync(async () => await packageManager.UninstallPackageAsync(nuGetProject, packageId, uninstallContext, projectContext, CancellationToken.None));
}
private static async Task<bool> RestorePackageAsync(NuGetPackageManager nuGetPackageManager,
PackageIdentity packageIdentity,
INuGetProjectContext nuGetProjectContext,
EventHandler<PackageRestoredEventArgs> packageRestoredEvent,
IEnumerable<SourceRepository> sourceRepositories,
CancellationToken token)
{
bool restored = await nuGetPackageManager.RestorePackageAsync(packageIdentity, nuGetProjectContext, sourceRepositories, token);
// At this point, it is guaranteed that package restore did not fail
if(packageRestoredEvent != null)
{
packageRestoredEvent(null, new PackageRestoredEventArgs(packageIdentity, restored));
}
return restored;
}
public async virtual Task<bool> RestoreMissingPackagesAsync(IEnumerable<PackageReference> packageReferences, CancellationToken token)
{
if(packageReferences == null)
{
throw new ArgumentNullException("packageReferences");
}
var nuGetPackageManager = new NuGetPackageManager(SourceRepositoryProvider, Settings, SolutionManager);
return await RestoreMissingPackages(nuGetPackageManager, packageReferences,
SolutionManager.NuGetProjectContext ?? new EmptyNuGetProjectContext(), token, PackageRestoredEvent);
}
public static async Task<bool> RestoreMissingPackages(NuGetPackageManager nuGetPackageManager,
IEnumerable<PackageReference> packageReferences,
INuGetProjectContext nuGetProjectContext,
CancellationToken token,
EventHandler<PackageRestoredEventArgs> packageRestoredEvent = null,
IEnumerable<SourceRepository> sourceRepositories = null)
{
if(nuGetPackageManager == null)
{
throw new ArgumentNullException("nuGetPackageManager");
}
if(packageReferences == null)
{
throw new ArgumentNullException("packageReferences");
}
if(nuGetProjectContext == null)
{
throw new ArgumentNullException("nuGetProjectContext");
}
if (!packageReferences.Any())
return false;
var hashSetOfMissingPackageReferences = new HashSet<PackageReference>(packageReferences, new PackageReferenceComparer());
// Before starting to restore package, set the nuGetProjectContext such that satellite files are not copied yet
// Satellite files will be copied as a post operation. This helps restore packages in parallel
// and not have to determine if the package is a satellite package beforehand
if(nuGetProjectContext.PackageExtractionContext == null)
{
nuGetProjectContext.PackageExtractionContext = new PackageExtractionContext();
}
nuGetProjectContext.PackageExtractionContext.CopySatelliteFiles = false;
token.ThrowIfCancellationRequested();
// TODO: Update this to use the locked version
bool[] results = await Task.WhenAll(hashSetOfMissingPackageReferences.Select(uniqueMissingPackage =>
RestorePackageAsync(nuGetPackageManager, uniqueMissingPackage.PackageIdentity, nuGetProjectContext,
packageRestoredEvent, sourceRepositories, token)));
token.ThrowIfCancellationRequested();
bool[] satelliteFileResults = await Task.WhenAll(hashSetOfMissingPackageReferences.Select(uniqueMissingPackage =>
nuGetPackageManager.CopySatelliteFilesAsync(uniqueMissingPackage.PackageIdentity, nuGetProjectContext, token)));
return results.Any() || satelliteFileResults.Any();
}
public IEnumerable<PackageReference> GetMissingPackages(IEnumerable<PackageReference> packageReferences)
{
var nuGetPackageManager = new NuGetPackageManager(SourceRepositoryProvider, Settings, SolutionManager);
return GetMissingPackages(nuGetPackageManager, packageReferences);
}
public static IEnumerable<PackageReference> GetMissingPackages(NuGetPackageManager nuGetPackageManager,
IEnumerable<PackageReference> packageReferences)
{
try
{
return new HashSet<PackageReference>(packageReferences.Where(pr => !nuGetPackageManager.PackageExistsInPackagesFolder(pr.PackageIdentity)),
new PackageReferenceComparer());
}
catch (Exception)
{
// if an exception happens during the check, assume no missing packages and move on.
// TODO : Write to NuGetProjectContext
return Enumerable.Empty<PackageReference>();
}
}
public async Task TestPacManPreviewInstallWithAllowedVersionsConstraint()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV2OnlySourceRepositoryProvider();
var testSolutionManager = new TestSolutionManager();
var testSettings = new NullSettings();
var token = CancellationToken.None;
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var randomPackagesConfigFolderPath = TestFilesystemUtility.CreateRandomTestFolder();
var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config");
var projectTargetFramework = NuGetFramework.Parse("net45");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigPath);
var newtonsoftJsonPackageId = "newtonsoft.json";
var newtonsoftJsonPackageIdentity = new PackageIdentity(newtonsoftJsonPackageId, NuGetVersion.Parse("4.5.11"));
var primarySourceRepository = sourceRepositoryProvider.GetRepositories().Single();
var resolutionContext = new ResolutionContext();
var testNuGetProjectContext = new TestNuGetProjectContext();
// Act
await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, newtonsoftJsonPackageIdentity,
resolutionContext, testNuGetProjectContext, primarySourceRepository, null, token);
// Assert
// Check that the packages.config file exists after the installation
Assert.True(File.Exists(randomPackagesConfigPath));
// Check the number of packages and packages returned by PackagesConfigProject after the installation
var packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(1, packagesInPackagesConfig.Count);
Assert.Equal(newtonsoftJsonPackageIdentity, packagesInPackagesConfig[0].PackageIdentity);
Assert.Equal(projectTargetFramework, packagesInPackagesConfig[0].TargetFramework);
var installedPackages = await msBuildNuGetProject.GetInstalledPackagesAsync(token);
var newtonsoftJsonPackageReference = installedPackages.Where(pr => pr.PackageIdentity.Equals(newtonsoftJsonPackageIdentity)).FirstOrDefault();
Assert.Null(newtonsoftJsonPackageReference.AllowedVersions);
const string newPackagesConfig = @"<?xml version='1.0' encoding='utf-8'?>
<packages>
<package id='Newtonsoft.Json' version='4.5.11' allowedVersions='[4.0,5.0)' targetFramework='net45' />
</packages> ";
File.WriteAllText(randomPackagesConfigPath, newPackagesConfig);
// Check that the packages.config file exists after the installation
Assert.True(File.Exists(randomPackagesConfigPath));
// Check the number of packages and packages returned by PackagesConfigProject after the installation
packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(1, packagesInPackagesConfig.Count);
Assert.Equal(newtonsoftJsonPackageIdentity, packagesInPackagesConfig[0].PackageIdentity);
Assert.Equal(projectTargetFramework, packagesInPackagesConfig[0].TargetFramework);
installedPackages = await msBuildNuGetProject.GetInstalledPackagesAsync(token);
newtonsoftJsonPackageReference = installedPackages.Where(pr => pr.PackageIdentity.Equals(newtonsoftJsonPackageIdentity)).FirstOrDefault();
Assert.NotNull(newtonsoftJsonPackageReference.AllowedVersions);
Exception exception = null;
try
{
// Main Act
await nuGetPackageManager.PreviewInstallPackageAsync(msBuildNuGetProject, newtonsoftJsonPackageId,
resolutionContext, testNuGetProjectContext, primarySourceRepository, null, token);
}
catch (Exception ex)
{
exception = ex;
}
Assert.NotNull(exception);
}
public MonoDevelopNuGetPackageManager (NuGetPackageManager packageManager)
{
this.packageManager = packageManager;
}
private void ExecuteInitScripts()
{
// Fix for Bug 1426 Disallow ExecuteInitScripts from being executed concurrently by multiple threads.
lock (_initScriptsLock)
{
if (!_solutionManager.IsSolutionOpen)
{
return;
}
Debug.Assert(_settings != null);
if (_settings == null)
{
return;
}
try
{
// invoke init.ps1 files in the order of package dependency.
// if A -> B, we invoke B's init.ps1 before A's.
IEnumerable<NuGetProject> projects = _solutionManager.GetNuGetProjects();
NuGetPackageManager packageManager = new NuGetPackageManager(_sourceRepositoryProvider, _settings, _solutionManager);
List<PackageIdentity> sortedPackages = new List<PackageIdentity>();
foreach (NuGetProject project in projects)
{
// Skip project K projects.
if (project is NuGet.ProjectManagement.Projects.ProjectKNuGetProjectBase)
{
continue;
}
IEnumerable<PackageReference> installedRefs = project.GetInstalledPackagesAsync(CancellationToken.None).Result;
if (installedRefs != null && installedRefs.Any())
{
IEnumerable<PackageIdentity> installedPackages = packageManager.GetInstalledPackagesInDependencyOrder(project, new EmptyNuGetProjectContext(), CancellationToken.None).Result;
sortedPackages.AddRange(installedPackages);
}
}
// Get the path to the Packages folder.
string packagesFolderPath = packageManager.PackagesFolderSourceRepository.PackageSource.Source;
foreach (var package in sortedPackages)
{
PackagePathResolver packagePathResolver = new PackagePathResolver(packagesFolderPath);
string pathToPackage = packagePathResolver.GetInstalledPath(package);
string toolsPath = Path.Combine(pathToPackage, "tools");
AddPathToEnvironment(toolsPath);
Runspace.ExecuteScript(toolsPath, PowerShellScripts.Init, package);
}
}
catch (Exception ex)
{
// When Packages folder is not present, NuGetResolverInputException will be thrown
// as resolving DependencyInfo requires the presence of Packages folder.
if (ex.InnerException is NuGetResolverInputException)
{
// Silently fail.
}
else
{
// if execution of Init scripts fails, do not let it crash our console
ReportError(ex);
}
ExceptionHelper.WriteToActivityLog(ex);
}
}
}
public async Task TestPacManUninstallPackageOnMultipleProjects()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var testSolutionManager = new TestSolutionManager();
var testSettings = new NullSettings();
var token = CancellationToken.None;
var resolutionContext = new ResolutionContext();
var testNuGetProjectContext = new TestNuGetProjectContext();
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var packagePathResolver = new PackagePathResolver(packagesFolderPath);
var projectA = testSolutionManager.AddNewMSBuildProject();
var projectB = testSolutionManager.AddNewMSBuildProject();
var packageIdentity = NoDependencyLibPackages[0];
// Act
await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity,
resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token);
await nuGetPackageManager.InstallPackageAsync(projectB, packageIdentity,
resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
var projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList();
var projectBInstalled = (await projectB.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(1, projectAInstalled.Count);
Assert.Equal(1, projectBInstalled.Count);
// Main Act
var uninstallationContext = new UninstallationContext();
await nuGetPackageManager.UninstallPackageAsync(projectA, packageIdentity.Id,
uninstallationContext, testNuGetProjectContext, token);
// Assert
projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList();
projectBInstalled = (await projectB.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(0, projectAInstalled.Count);
Assert.Equal(1, projectBInstalled.Count);
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity)));
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory);
}
public async Task TestPacManPreviewUpdateWithAllowedVersionsConstraint()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV2OnlySourceRepositoryProvider();
var testSolutionManager = new TestSolutionManager();
var testSettings = new NullSettings();
var token = CancellationToken.None;
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var randomPackagesConfigFolderPath = TestFilesystemUtility.CreateRandomTestFolder();
var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config");
var projectTargetFramework = NuGetFramework.Parse("net45");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigPath);
var newtonsoftJsonPackageId = "newtonsoft.json";
var newtonsoftJsonPackageIdentity = new PackageIdentity(newtonsoftJsonPackageId, NuGetVersion.Parse("4.5.11"));
var primarySourceRepository = sourceRepositoryProvider.GetRepositories().Single();
var resolutionContext = new ResolutionContext(DependencyBehavior.Highest);
var testNuGetProjectContext = new TestNuGetProjectContext();
// Act
await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, newtonsoftJsonPackageIdentity,
resolutionContext, testNuGetProjectContext, primarySourceRepository, null, token);
await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, new PackageIdentity("Microsoft.Web.Infrastructure", new NuGetVersion("1.0.0.0")),
resolutionContext, testNuGetProjectContext, primarySourceRepository, null, token);
// Assert
// Check that the packages.config file exists after the installation
Assert.True(File.Exists(randomPackagesConfigPath));
// Check the number of packages and packages returned by PackagesConfigProject after the installation
var packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(2, packagesInPackagesConfig.Count);
Assert.Equal(newtonsoftJsonPackageIdentity, packagesInPackagesConfig[1].PackageIdentity);
Assert.Equal(projectTargetFramework, packagesInPackagesConfig[1].TargetFramework);
var installedPackages = await msBuildNuGetProject.GetInstalledPackagesAsync(token);
var newtonsoftJsonPackageReference = installedPackages.Where(pr => pr.PackageIdentity.Equals(newtonsoftJsonPackageIdentity)).FirstOrDefault();
Assert.Null(newtonsoftJsonPackageReference.AllowedVersions);
const string newPackagesConfig = @"<?xml version='1.0' encoding='utf-8'?>
<packages>
<package id='Microsoft.Web.Infrastructure' version='1.0.0.0' targetFramework='net45' />
<package id='Newtonsoft.Json' version='4.5.11' allowedVersions='[4.0,5.0)' targetFramework='net45' />
</packages> ";
File.WriteAllText(randomPackagesConfigPath, newPackagesConfig);
// Check that the packages.config file exists after the installation
Assert.True(File.Exists(randomPackagesConfigPath));
// Check the number of packages and packages returned by PackagesConfigProject after the installation
packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(2, packagesInPackagesConfig.Count);
Assert.Equal(newtonsoftJsonPackageIdentity, packagesInPackagesConfig[1].PackageIdentity);
Assert.Equal(projectTargetFramework, packagesInPackagesConfig[1].TargetFramework);
installedPackages = await msBuildNuGetProject.GetInstalledPackagesAsync(token);
newtonsoftJsonPackageReference = installedPackages.Where(pr => pr.PackageIdentity.Equals(newtonsoftJsonPackageIdentity)).FirstOrDefault();
Assert.NotNull(newtonsoftJsonPackageReference.AllowedVersions);
// Main Act
var nuGetProjectActions = (await nuGetPackageManager.PreviewUpdatePackagesAsync(new List<string>() { newtonsoftJsonPackageId, "Microsoft.Web.Infrastructure" }, msBuildNuGetProject,
resolutionContext, testNuGetProjectContext, primarySourceRepository, null, token)).ToList();
// Microsoft.Web.Infrastructure has no updates. However, newtonsoft.json has updates but does not satisfy the version range
// Hence, no nuget project actions to perform
Assert.Equal(0, nuGetProjectActions.Count);
}
public async Task<NuGetInstallResult> InstallPackage(
string packageId,
NuGetVersion version,
bool prerelease)
{
var installPath = Path.Combine(Path.GetTempPath(), "testnuget");
var projectContext = new EmptyNuGetProjectContext
{
PackageExtractionContext = new PackageExtractionContext()
};
var references = new List<string>();
var frameworkReferences = new List<string>();
var projectSystem = new DelegateNuGetProjectSystem(projectContext, (reference, isFrameworkReference) =>
{
if (isFrameworkReference) frameworkReferences.Add(reference);
else references.Add(reference);
});
var project = new MSBuildNuGetProject(projectSystem, installPath, installPath);
OverrideProject(project);
var packageManager = new NuGetPackageManager(_sourceRepositoryProvider, _settings, installPath);
var primaryRepositories = _packageSources.Select(_sourceRepositoryProvider.CreateRepository).ToArray();
var resolutionContext = new ResolutionContext(
DependencyBehavior.Lowest,
includePrelease: prerelease,
includeUnlisted: true,
versionConstraints: VersionConstraints.None);
if (version == null)
{
// Find the latest version using NuGetPackageManager
version = await NuGetPackageManager.GetLatestVersionAsync(
packageId,
project,
resolutionContext,
primaryRepositories,
NullLogger.Instance,
CancellationToken.None).ConfigureAwait(false);
if (version == null)
{
throw new Exception("Unable to find package");
}
}
var packageIdentity = new PackageIdentity(packageId, version);
await packageManager.InstallPackageAsync(
project,
packageIdentity,
resolutionContext,
projectContext,
primaryRepositories,
Enumerable.Empty<SourceRepository>(),
CancellationToken.None).ConfigureAwait(false);
return new NuGetInstallResult(references.AsReadOnly(), frameworkReferences.AsReadOnly());
}
/// <summary>
/// Core install method. All installs from the VS API and template wizard end up here.
/// </summary>
internal async Task InstallInternal(Project project, List<PackageIdentity> packages, ISourceRepositoryProvider repoProvider, VSAPIProjectContext projectContext, bool ignoreDependencies, CancellationToken token)
{
// store expanded node state
IDictionary<string, ISet<VsHierarchyItem>> expandedNodes = VsHierarchyHelper.GetAllExpandedNodes(_solutionManager);
try
{
DependencyBehavior depBehavior = ignoreDependencies ? DependencyBehavior.Ignore : DependencyBehavior.Lowest;
bool includePrerelease = false;
ResolutionContext resolution = new ResolutionContext(depBehavior, includePrerelease, false);
NuGetPackageManager packageManager = new NuGetPackageManager(repoProvider, _settings, _solutionManager);
// find the project
NuGetProject nuGetProject = PackageManagementHelpers.GetProject(_solutionManager, project, projectContext);
// install the package
foreach (PackageIdentity package in packages)
{
if (package.Version == null)
{
if (!_packageServices.IsPackageInstalled(project, package.Id))
{
await packageManager.InstallPackageAsync(nuGetProject, package.Id, resolution, projectContext, repoProvider.GetRepositories(), Enumerable.Empty<SourceRepository>(), token);
}
}
else
{
if (!_packageServices.IsPackageInstalledEx(project, package.Id, package.Version.ToString()))
{
await packageManager.InstallPackageAsync(nuGetProject, package, resolution, projectContext, repoProvider.GetRepositories(), Enumerable.Empty<SourceRepository>(), token);
}
}
}
}
finally
{
// collapse nodes
VsHierarchyHelper.CollapseAllNodes(_solutionManager, expandedNodes);
}
}
public async Task TestPacManPreviewInstallOrderOfDependencies()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV2OnlySourceRepositoryProvider();
var testSolutionManager = new TestSolutionManager();
var testSettings = new NullSettings();
var token = CancellationToken.None;
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var randomPackagesConfigFolderPath = TestFilesystemUtility.CreateRandomTestFolder();
var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config");
var projectTargetFramework = NuGetFramework.Parse("net45");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigPath);
var packageIdentity = MorePackageWithDependents[3];
// Pre-Assert
// Check that the packages.config file does not exist
Assert.False(File.Exists(randomPackagesConfigPath));
// Check that there are no packages returned by PackagesConfigProject
var packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(0, packagesInPackagesConfig.Count);
Assert.Equal(0, msBuildNuGetProjectSystem.References.Count);
// Act
var packageActions = (await nuGetPackageManager.PreviewInstallPackageAsync(msBuildNuGetProject, packageIdentity,
new ResolutionContext(), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token)).ToList();
// Assert
Assert.Equal(3, packageActions.Count);
Assert.True(MorePackageWithDependents[0].Equals(packageActions[0].PackageIdentity));
Assert.Equal(NuGetProjectActionType.Install, packageActions[0].NuGetProjectActionType);
Assert.Equal(sourceRepositoryProvider.GetRepositories().Single().PackageSource.Source,
packageActions[0].SourceRepository.PackageSource.Source);
Assert.True(MorePackageWithDependents[2].Equals(packageActions[1].PackageIdentity));
Assert.Equal(NuGetProjectActionType.Install, packageActions[1].NuGetProjectActionType);
Assert.Equal(sourceRepositoryProvider.GetRepositories().Single().PackageSource.Source,
packageActions[0].SourceRepository.PackageSource.Source);
Assert.True(MorePackageWithDependents[3].Equals(packageActions[2].PackageIdentity));
Assert.Equal(NuGetProjectActionType.Install, packageActions[2].NuGetProjectActionType);
Assert.Equal(sourceRepositoryProvider.GetRepositories().Single().PackageSource.Source,
packageActions[0].SourceRepository.PackageSource.Source);
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory, randomPackagesConfigFolderPath);
}
public async Task Install(IReadOnlyList<SourceRepository> remoteRepositories, NuGetPackageManager packageManager)
{
if (_versionMatch == null)
{
return;
}
IReadOnlyList<SourceRepository> sourceRepositories = GetSourceRepositories(remoteRepositories);
Trace.Verbose($"Installing package {_packageId} {_versionMatch.Version}");
ResolutionContext resolutionContext = new ResolutionContext(
DependencyBehavior.Lowest, _allowPrereleaseVersions, _allowUnlisted, VersionConstraints.None);
INuGetProjectContext projectContext = new NuGetProjectContext();
await packageManager.InstallPackageAsync(packageManager.PackagesFolderNuGetProject,
new PackageIdentity(_packageId, _versionMatch), resolutionContext, projectContext, sourceRepositories,
Array.Empty<SourceRepository>(), CancellationToken.None);
Trace.Verbose($"Installed package {_packageId} {_versionMatch.Version}");
}
public async Task TestPacManInstallPackageWhichUsesExistingDependency()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var testSolutionManager = new TestSolutionManager();
var testSettings = new NullSettings();
var token = CancellationToken.None;
var resolutionContext = new ResolutionContext();
var testNuGetProjectContext = new TestNuGetProjectContext();
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var packagePathResolver = new PackagePathResolver(packagesFolderPath);
var projectA = testSolutionManager.AddNewMSBuildProject();
var packageIdentity0 = PackageWithDependents[0];
var packageIdentity1 = PackageWithDependents[1];
var packageIdentity2 = PackageWithDependents[2];
var packageIdentity3 = PackageWithDependents[3];
// Act
await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity3,
resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
var projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(2, projectAInstalled.Count);
Assert.Equal(packageIdentity1, projectAInstalled[0].PackageIdentity);
Assert.Equal(packageIdentity3, projectAInstalled[1].PackageIdentity);
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity1)));
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity3)));
// Main Act
await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity2,
resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(3, projectAInstalled.Count);
Assert.Equal(packageIdentity1, projectAInstalled[0].PackageIdentity);
Assert.Equal(packageIdentity2, projectAInstalled[2].PackageIdentity);
Assert.Equal(packageIdentity3, projectAInstalled[1].PackageIdentity);
Assert.False(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity0)));
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity1)));
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity2)));
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity3)));
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory);
}
public async Task TestPacManInstallLowerSpecificVersionOfDependencyPackage()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var testSolutionManager = new TestSolutionManager();
var testSettings = new NullSettings();
var token = CancellationToken.None;
var resolutionContext = new ResolutionContext(DependencyBehavior.Highest);
var testNuGetProjectContext = new TestNuGetProjectContext();
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var packagePathResolver = new PackagePathResolver(packagesFolderPath);
var projectA = testSolutionManager.AddNewMSBuildProject();
var packageIdentity0 = PackageWithDependents[0];
var dependentPackage = PackageWithDependents[2];
var latestVersion = await NuGetPackageManager.GetLatestVersionAsync(packageIdentity0.Id, resolutionContext,
sourceRepositoryProvider.GetRepositories().First(), token);
var packageLatest = new PackageIdentity(packageIdentity0.Id, latestVersion);
// Act
await nuGetPackageManager.InstallPackageAsync(projectA, dependentPackage,
resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
var projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(2, projectAInstalled.Count);
Assert.Equal(packageLatest, projectAInstalled[0].PackageIdentity);
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageLatest)));
Assert.Equal(dependentPackage, projectAInstalled[1].PackageIdentity);
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(dependentPackage)));
Assert.False(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity0)));
// Main Act
await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity0,
resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(2, projectAInstalled.Count);
Assert.Equal(packageIdentity0, projectAInstalled[0].PackageIdentity);
Assert.Equal(dependentPackage, projectAInstalled[1].PackageIdentity);
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(dependentPackage)));
Assert.False(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageLatest)));
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity0)));
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory);
}
/// <summary>
/// Устанавливает пакет.
/// </summary>
/// <param name="packageId">ID пакета.</param>
/// <param name="packageVersion">Версия пакета.</param>
/// <param name="allowPrerelease">Разрешена ли установка предварительного релиза.</param>
/// <returns>Содержимое установленного пакета.</returns>
public async Task<PackageContent> InstallPackage(string packageId, string packageVersion = null, bool allowPrerelease = false)
{
NuGetVersion packageNuGetVersion = null;
if (!string.IsNullOrWhiteSpace(packageVersion))
{
packageNuGetVersion = NuGetVersion.Parse(packageVersion);
}
// Конфигурационный файл NuGet.config по умолчанию
var settings = new NuGet.Configuration.Settings(_packagesPath, "NuGet.config");
// Фабрика источников пактов на основе конфигурационного файла
var packageSourceProvider = new PackageSourceProvider(settings);
// Добавление в фабрику источников пакетов дополнительных источников
packageSourceProvider.SavePackageSources(_packageSources.Select(i => new PackageSource(i)));
// Фабрика хранилищ пакетов на основе фабрики источников пакетов
var packageRepositoryProvider = new CachingSourceProvider(packageSourceProvider);
// Получение всех хранилищ пакетов на основе указанных источников
var packageRepositories = packageRepositoryProvider.GetRepositories().ToList();
// Определение возможности установки prerelease-версии пакетов
allowPrerelease = allowPrerelease || (packageNuGetVersion != null && packageNuGetVersion.IsPrerelease);
// Создание правил разрешения зависимостей при установке пакета
var resolutionContext = new ResolutionContext(
dependencyBehavior: DependencyBehavior.Lowest,
includePrelease: allowPrerelease,
includeUnlisted: true,
versionConstraints: VersionConstraints.None);
// Если версия пакета не указана, поиск последней версии
if (packageNuGetVersion == null)
{
packageNuGetVersion = await NuGetPackageManager.GetLatestVersionAsync(
packageId,
NuGetFramework.AnyFramework,
resolutionContext,
packageRepositories,
_logger,
CancellationToken.None);
if (packageNuGetVersion == null)
{
throw new InvalidOperationException(string.Format(Properties.Resources.PackageNotFound, packageId));
}
}
// Уникальный идентификатор версии пакета для установки
var packageIdentity = new PackageIdentity(packageId, packageNuGetVersion);
// Каталог для установки пакетов (каталог packages)
NuGetProject folderProject = new InfinniFolderNuGetProject(_packagesPath);
// Менеджер для управления пакетами
var packageManager = new NuGetPackageManager(packageRepositoryProvider, settings, _packagesPath);
// Правила установки пакетов
var projectContext = new NuGetLoggerProjectContext(_logger)
{
PackageExtractionContext = new PackageExtractionContext
{
PackageSaveMode = PackageSaveMode.Defaultv3
}
};
// Определение порядка действий при установке пакета
var installActions = (await packageManager.PreviewInstallPackageAsync(
folderProject,
packageIdentity,
resolutionContext,
projectContext,
packageRepositories,
Enumerable.Empty<SourceRepository>(),
CancellationToken.None)).ToList();
// Применение действий по установке пакета
await packageManager.ExecuteNuGetProjectActionsAsync(
folderProject,
installActions,
projectContext,
CancellationToken.None);
return GetPackageContent(packageIdentity, installActions.Select(i => i.PackageIdentity).ToList());
}
internal void InstallPackages()
{
DirectoryPath packagesPath = GetAbsolutePackagesPath();
Trace.Verbose($"Installing packages to {packagesPath.FullPath} (using {(UseLocalPackagesFolder ? "local" : "global")} packages folder)");
try
{
// Add the global default sources if requested
if (UseGlobalPackageSources)
{
_sourceRepositories.AddGlobalDefaults();
}
// Get the local repository
SourceRepository localRepository = _sourceRepositories.CreateRepository(packagesPath.FullPath);
// Get the package manager and repositories
WyamFolderNuGetProject nuGetProject = new WyamFolderNuGetProject(_fileSystem, _assemblyLoader, _currentFramework, packagesPath.FullPath);
NuGetPackageManager packageManager = new NuGetPackageManager(_sourceRepositories, _settings, packagesPath.FullPath)
{
PackagesFolderNuGetProject = nuGetProject
};
IReadOnlyList<SourceRepository> remoteRepositories = _sourceRepositories.GetDefaultRepositories();
// Resolve all the versions
IReadOnlyList<SourceRepository> installationRepositories = remoteRepositories;
try
{
ResolveVersions(localRepository, remoteRepositories);
}
catch (Exception ex)
{
Trace.Warning("Exception while resolving package versions, attempting without remote repositories");
Trace.Verbose($"Exception while resolving package versions: {ex.Message}");
installationRepositories = new[] {localRepository};
ResolveVersions(localRepository, Array.Empty<SourceRepository>());
}
// Install the packages (doing this synchronously since doing it in parallel triggers file lock errors in NuGet on a clean system)
try
{
InstallPackages(packageManager, installationRepositories);
}
catch (Exception ex)
{
Trace.Warning("Exception while installing packages, attempting without remote repositories");
Trace.Verbose($"Exception while installing packages: {(ex is AggregateException ? string.Join("; ", ((AggregateException)ex).InnerExceptions.Select(x => x.Message)) : ex.Message)}");
InstallPackages(packageManager, new[] { localRepository });
}
// Process the package (do this after all packages have been installed)
nuGetProject.ProcessAssembliesAndContent();
}
catch (Exception ex)
{
Trace.Warning("Unexpected exception while installing packages, attempting to continue anyway");
Trace.Verbose($"Unexpected exception while installing packages: {(ex is AggregateException ? string.Join("; ", ((AggregateException)ex).InnerExceptions.Select(x => x.Message)) : ex.Message)}");
}
}
private void InstallPackages(NuGetPackageManager packageManager, IReadOnlyList<SourceRepository> installationRepositories)
{
foreach (Package package in _packages.Values)
{
package.Install(installationRepositories, packageManager).Wait();
}
}
public async Task TestPacManPreviewUninstallDependencyPackage()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var testSolutionManager = new TestSolutionManager();
var testSettings = new NullSettings();
var token = CancellationToken.None;
var resolutionContext = new ResolutionContext();
var testNuGetProjectContext = new TestNuGetProjectContext();
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager);
var randomPackagesConfigFolderPath = TestFilesystemUtility.CreateRandomTestFolder();
var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config");
var projectTargetFramework = NuGetFramework.Parse("net45");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigPath);
var packageIdentity = PackageWithDependents[2];
// Pre-Assert
// Check that the packages.config file does not exist
Assert.False(File.Exists(randomPackagesConfigPath));
// Check that there are no packages returned by PackagesConfigProject
var packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(0, packagesInPackagesConfig.Count);
Assert.Equal(0, msBuildNuGetProjectSystem.References.Count);
// Act
await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, packageIdentity,
resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
// Check that the packages.config file exists after the installation
Assert.True(File.Exists(randomPackagesConfigPath));
// Check the number of packages and packages returned by PackagesConfigProject after the installation
packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(2, packagesInPackagesConfig.Count);
Assert.Equal(packageIdentity, packagesInPackagesConfig[1].PackageIdentity);
Assert.Equal(projectTargetFramework, packagesInPackagesConfig[1].TargetFramework);
Assert.Equal(PackageWithDependents[0], packagesInPackagesConfig[0].PackageIdentity);
Assert.Equal(projectTargetFramework, packagesInPackagesConfig[0].TargetFramework);
// Main Act
Exception exception = null;
try
{
var uninstallationContext = new UninstallationContext();
var packageActions = await nuGetPackageManager.PreviewUninstallPackageAsync(msBuildNuGetProject, "jQuery",
uninstallationContext, testNuGetProjectContext, token);
}
catch (InvalidOperationException ex)
{
exception = ex;
}
catch (AggregateException ex)
{
exception = ExceptionUtility.Unwrap(ex);
}
Assert.NotNull(exception);
Assert.True(exception is InvalidOperationException);
Assert.Equal("Unable to uninstall 'jQuery.1.4.4' because 'jQuery.Validation.1.13.1' depends on it.",
exception.Message);
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory, randomPackagesConfigFolderPath);
}
