public static async Task <Tuple <string, IEnumerable <string> > > GetSatelliteFilesAsync(
PackageReaderBase packageReader,
PackagePathResolver packagePathResolver,
CancellationToken cancellationToken)
{
var satelliteFileEntries = new List <string>();
string runtimePackageDirectory = null;
var result = await GetSatellitePackageInfoAsync(packageReader, cancellationToken);
if (result.IsSatellitePackage)
{
// Now, we know that the package is a satellite package and that the runtime package is 'runtimePackageId'
// Check, if the runtimePackage is installed and get the folder to copy over files
var runtimePackageFilePath = packagePathResolver.GetInstalledPackageFilePath(result.RuntimePackageIdentity);
if (File.Exists(runtimePackageFilePath))
{
// Existence of the package file is the validation that the package exists
runtimePackageDirectory = Path.GetDirectoryName(runtimePackageFilePath);
satelliteFileEntries.AddRange(await packageReader.GetSatelliteFilesAsync(result.PackageLanguage, cancellationToken));
}
}
return(new Tuple <string, IEnumerable <string> >(runtimePackageDirectory, satelliteFileEntries));
}
public static IEnumerable <string> GetSatelliteFiles(
PackageReaderBase packageReader,
PackagePathResolver packagePathResolver,
out string runtimePackageDirectory)
{
var satelliteFileEntries = new List <string>();
runtimePackageDirectory = null;
PackageIdentity runtimePackageIdentity = null;
string packageLanguage = null;
if (IsSatellitePackage(packageReader, out runtimePackageIdentity, out packageLanguage))
{
// Now, we know that the package is a satellite package and that the runtime package is 'runtimePackageId'
// Check, if the runtimePackage is installed and get the folder to copy over files
var runtimePackageFilePath = packagePathResolver.GetInstalledPackageFilePath(runtimePackageIdentity);
if (File.Exists(runtimePackageFilePath))
{
// Existence of the package file is the validation that the package exists
runtimePackageDirectory = Path.GetDirectoryName(runtimePackageFilePath);
satelliteFileEntries.AddRange(packageReader.GetSatelliteFiles(packageLanguage));
}
}
return(satelliteFileEntries);
}
public static async Task <IEnumerable <string> > CopySatelliteFilesAsync(PackageIdentity packageIdentity, PackagePathResolver packagePathResolver,
PackageSaveModes packageSaveMode, CancellationToken token)
{
IEnumerable <string> satelliteFilesCopied = Enumerable.Empty <string>();
if (packageIdentity == null)
{
throw new ArgumentNullException("packageIdentity");
}
if (packagePathResolver == null)
{
throw new ArgumentNullException("packagePathResolver");
}
string nupkgFilePath = packagePathResolver.GetInstalledPackageFilePath(packageIdentity);
if (File.Exists(nupkgFilePath))
{
using (var packageStream = File.OpenRead(nupkgFilePath))
{
string language;
string runtimePackageDirectory;
IEnumerable <ZipArchiveEntry> satelliteFiles;
if (PackageHelper.GetSatelliteFiles(packageStream, packageIdentity, packagePathResolver, out language, out runtimePackageDirectory, out satelliteFiles))
{
// Now, add all the satellite files collected from the package to the runtime package folder(s)
satelliteFilesCopied = await PackageHelper.CreatePackageFiles(satelliteFiles, runtimePackageDirectory, packageSaveMode, token);
}
}
}
return(satelliteFilesCopied);
}
public static bool GetSatelliteFiles(Stream packageStream, PackageIdentity packageIdentity, PackagePathResolver packagePathResolver,
out string language, out string runtimePackageDirectory, out IEnumerable <ZipArchiveEntry> satelliteFiles)
{
var zipArchive = new ZipArchive(packageStream);
var packageReader = new PackageReader(zipArchive);
var nuspecReader = new NuspecReader(packageReader.GetNuspec());
PackageIdentity runtimePackageIdentity = null;
string packageLanguage = null;
if (PackageHelper.IsSatellitePackage(nuspecReader, out runtimePackageIdentity, out packageLanguage))
{
// Now, we know that the package is a satellite package and that the runtime package is 'runtimePackageId'
// Check, if the runtimePackage is installed and get the folder to copy over files
string runtimePackageFilePath = packagePathResolver.GetInstalledPackageFilePath(runtimePackageIdentity);
if (File.Exists(runtimePackageFilePath))
{
runtimePackageDirectory = Path.GetDirectoryName(runtimePackageFilePath);
// Existence of the package file is the validation that the package exists
var libItemGroups = packageReader.GetLibItems();
List <ZipArchiveEntry> satelliteFileEntries = new List <ZipArchiveEntry>();
foreach (var libItemGroup in libItemGroups)
{
var satelliteFilesInGroup = libItemGroup.Items.Where(item => Path.GetDirectoryName(item).Split(Path.DirectorySeparatorChar)
.Contains(packageLanguage, StringComparer.OrdinalIgnoreCase));
foreach (var satelliteFile in satelliteFilesInGroup)
{
var zipArchiveEntry = zipArchive.GetEntry(satelliteFile);
if (zipArchiveEntry != null)
{
satelliteFileEntries.Add(zipArchiveEntry);
}
}
}
if (satelliteFileEntries.Count > 0)
{
language = packageLanguage;
satelliteFiles = satelliteFileEntries;
return(true);
}
}
}
language = null;
runtimePackageDirectory = null;
satelliteFiles = null;
return(false);
}
public static async Task <IEnumerable <string> > CopySatelliteFilesAsync(
PackageIdentity packageIdentity,
PackagePathResolver packagePathResolver,
PackageSaveMode packageSaveMode,
PackageExtractionContext packageExtractionContext,
CancellationToken token)
{
if (packageIdentity == null)
{
throw new ArgumentNullException(nameof(packageIdentity));
}
if (packagePathResolver == null)
{
throw new ArgumentNullException(nameof(packagePathResolver));
}
var satelliteFilesCopied = Enumerable.Empty <string>();
var nupkgFilePath = packagePathResolver.GetInstalledPackageFilePath(packageIdentity);
if (File.Exists(nupkgFilePath))
{
using (var packageReader = new PackageArchiveReader(nupkgFilePath))
{
return(await CopySatelliteFilesAsync(
packageReader,
packagePathResolver,
packageSaveMode,
packageExtractionContext,
token));
}
}
return(satelliteFilesCopied);
}
public static bool GetSatelliteFiles(Stream packageStream, PackageIdentity packageIdentity, PackagePathResolver packagePathResolver,
out string language, out string runtimePackageDirectory, out IEnumerable<ZipArchiveEntry> satelliteFiles)
{
var zipArchive = new ZipArchive(packageStream);
var packageReader = new PackageReader(zipArchive);
var nuspecReader = new NuspecReader(packageReader.GetNuspec());
PackageIdentity runtimePackageIdentity = null;
string packageLanguage = null;
if (IsSatellitePackage(nuspecReader, out runtimePackageIdentity, out packageLanguage))
{
// Now, we know that the package is a satellite package and that the runtime package is 'runtimePackageId'
// Check, if the runtimePackage is installed and get the folder to copy over files
var runtimePackageFilePath = packagePathResolver.GetInstalledPackageFilePath(runtimePackageIdentity);
if (File.Exists(runtimePackageFilePath))
{
runtimePackageDirectory = Path.GetDirectoryName(runtimePackageFilePath);
// Existence of the package file is the validation that the package exists
var libItemGroups = packageReader.GetLibItems();
var satelliteFileEntries = new List<ZipArchiveEntry>();
foreach (var libItemGroup in libItemGroups)
{
var satelliteFilesInGroup = libItemGroup.Items.Where(item => Path.GetDirectoryName(item).Split(Path.DirectorySeparatorChar)
.Contains(packageLanguage, StringComparer.OrdinalIgnoreCase));
foreach (var satelliteFile in satelliteFilesInGroup)
{
var zipArchiveEntry = zipArchive.GetEntry(satelliteFile);
if (zipArchiveEntry != null)
{
satelliteFileEntries.Add(zipArchiveEntry);
}
}
}
if (satelliteFileEntries.Count > 0)
{
language = packageLanguage;
satelliteFiles = satelliteFileEntries;
return true;
}
}
}
language = null;
runtimePackageDirectory = null;
satelliteFiles = null;
return false;
}
public static async Task<IEnumerable<string>> CopySatelliteFilesAsync(PackageIdentity packageIdentity, PackagePathResolver packagePathResolver,
PackageSaveModes packageSaveMode, CancellationToken token)
{
var satelliteFilesCopied = Enumerable.Empty<string>();
if (packageIdentity == null)
{
throw new ArgumentNullException("packageIdentity");
}
if (packagePathResolver == null)
{
throw new ArgumentNullException("packagePathResolver");
}
var nupkgFilePath = packagePathResolver.GetInstalledPackageFilePath(packageIdentity);
if (File.Exists(nupkgFilePath))
{
using (var packageStream = File.OpenRead(nupkgFilePath))
{
string language;
string runtimePackageDirectory;
IEnumerable<ZipArchiveEntry> satelliteFiles;
if (PackageHelper.GetSatelliteFiles(packageStream, packageIdentity, packagePathResolver, out language, out runtimePackageDirectory, out satelliteFiles))
{
// Now, add all the satellite files collected from the package to the runtime package folder(s)
satelliteFilesCopied = await PackageHelper.CreatePackageFiles(satelliteFiles, runtimePackageDirectory, packageSaveMode, token);
}
}
}
return satelliteFilesCopied;
}
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);
}
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 TestPacManUninstallPackage()
{
// 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 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,
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(1, packagesInPackagesConfig.Count);
Assert.Equal(packageIdentity, packagesInPackagesConfig[0].PackageIdentity);
Assert.Equal(projectTargetFramework, packagesInPackagesConfig[0].TargetFramework);
// Main Act
var uninstallationContext = new UninstallationContext();
await nuGetPackageManager.UninstallPackageAsync(msBuildNuGetProject, packageIdentity.Id,
uninstallationContext, testNuGetProjectContext, 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(0, packagesInPackagesConfig.Count);
Assert.False(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity)));
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory, randomPackagesConfigFolderPath);
}
public async Task TestPacManUninstallWithRemoveDependenciesWithVDependency()
{
// 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, packageIdentity2,
resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
var projectAInstalled = (await projectA.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(2, projectAInstalled.Count);
Assert.Equal(packageIdentity0, projectAInstalled[0].PackageIdentity);
Assert.Equal(packageIdentity2, projectAInstalled[1].PackageIdentity);
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity0)));
Assert.True(File.Exists(packagePathResolver.GetInstalledPackageFilePath(packageIdentity2)));
// Main Act
await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity3,
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)));
// Main Act
Exception exception = null;
try
{
var uninstallationContext = new UninstallationContext(removeDependencies: true);
await nuGetPackageManager.UninstallPackageAsync(projectA, packageIdentity2.Id,
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.6.4' because 'jQuery.UI.Combined.1.11.2' depends on it.",
exception.Message);
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(testSolutionManager.SolutionDirectory);
}
