/// <summary>
/// TEST method: Adds packages to the test source.
/// </summary>
/// <param name="packages">List of packages to be added</param>
/// <param name="packageLevel">0 if nupkg is at {root}\, 1 if nupkg is at directory {root}\{packageId}\
/// and 2 if nupkg is at directory {root}\{packageId}\{packageVersion}\. </param>
/// <returns></returns>
public IList <PackageIdentity> AddPackagesToSource(
List <PackageIdentity> packages,
int packageLevel)
{
foreach (var package in packages)
{
var packageDirectory = SourceFeed;
if (packageLevel == 2)
{
packageDirectory = Path.Combine(SourceFeed, package.Id, package.Version.ToString());
Directory.CreateDirectory(packageDirectory);
}
else if (packageLevel == 1)
{
packageDirectory = Path.Combine(SourceFeed, package.Id);
Directory.CreateDirectory(packageDirectory);
}
TestPackagesGroupedByFolder.GetLegacyTestPackage(packageDirectory,
package.Id,
package.Version.ToString());
}
return(packages);
}
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);
}
}
}
public async Task TestCheckForMissingPackages()
{
// Arrange
using (var testSolutionManager = new TestSolutionManager(true))
using (var randomPackageSourcePath = TestFileSystemUtility.CreateRandomTestFolder())
{
var projectA = testSolutionManager.AddNewMSBuildProject();
var projectB = testSolutionManager.AddNewMSBuildProject();
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage(randomPackageSourcePath,
packageIdentity.Id, packageIdentity.Version.ToNormalizedString());
var testNuGetProjectContext = new TestNuGetProjectContext();
var token = CancellationToken.None;
using (var packageStream = GetDownloadResult(packageFileInfo))
{
// Act
await projectA.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token);
await projectB.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token);
}
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var testSettings = Configuration.NullSettings.Instance;
var deleteOnRestartManager = new TestDeleteOnRestartManager();
var packageRestoreManager = new PackageRestoreManager(
sourceRepositoryProvider,
testSettings,
testSolutionManager);
var packagesMissingEventCount = 0;
var packagesMissing = false;
packageRestoreManager.PackagesMissingStatusChanged += delegate(object sender, PackagesMissingStatusEventArgs args)
{
packagesMissingEventCount++;
packagesMissing = args.PackagesMissing;
};
// Act
await packageRestoreManager.RaisePackagesMissingEventForSolutionAsync(testSolutionManager.SolutionDirectory, token);
// Assert
Assert.Equal(1, packagesMissingEventCount);
Assert.False(packagesMissing);
// Delete packages folder
TestFileSystemUtility.DeleteRandomTestFolder(Path.Combine(testSolutionManager.SolutionDirectory, "packages"));
// Act
await packageRestoreManager.RaisePackagesMissingEventForSolutionAsync(testSolutionManager.SolutionDirectory, token);
// Assert
Assert.Equal(2, packagesMissingEventCount);
Assert.True(packagesMissing);
}
}
public void Init(string sourceParamFolder)
{
_randomNupkgDirectory = TestDirectory.Create();
var testPackage = TestPackagesGroupedByFolder.GetLegacyTestPackage(
_randomNupkgDirectory,
Package.Id,
Package.Version.ToString());
Init(sourceParamFolder, testPackage);
}
public void Init(string sourceParamFolder)
{
var randomNupkgFolder = TestFileSystemUtility.CreateRandomTestFolder();
var testPackage = TestPackagesGroupedByFolder.GetLegacyTestPackage(
randomNupkgFolder,
Package.Id,
Package.Version.ToString());
Init(sourceParamFolder, testPackage);
}
public async Task TestBuildIntegratedNuGetProjectUninstallAllPackages()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
var packageIdentity2 = new PackageIdentity("packageB", new NuGetVersion("1.0.0"));
using (var randomTestPackageSourcePath = TestDirectory.Create())
using (var randomPackagesFolderPath = TestDirectory.Create())
using (var randomProjectFolderPath = TestDirectory.Create())
{
var randomConfig = Path.Combine(randomProjectFolderPath, "project.json");
var token = CancellationToken.None;
CreateConfigJson(randomConfig);
var projectTargetFramework = NuGetFramework.Parse("netcore50");
var testNuGetProjectContext = new TestNuGetProjectContext();
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, testNuGetProjectContext, randomProjectFolderPath);
var projectFilePath = Path.Combine(randomProjectFolderPath, $"{msBuildNuGetProjectSystem.ProjectName}.csproj");
var buildIntegratedProject = new ProjectJsonNuGetProject(randomConfig, projectFilePath);
var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyContentPackage(randomTestPackageSourcePath,
packageIdentity.Id, packageIdentity.Version.ToNormalizedString());
var packageFileInfo2 = TestPackagesGroupedByFolder.GetLegacyContentPackage(randomTestPackageSourcePath,
packageIdentity.Id, packageIdentity.Version.ToNormalizedString());
using (var packageStream = GetDownloadResourceResult(packageFileInfo))
{
await buildIntegratedProject.InstallPackageAsync(
packageIdentity.Id,
new VersionRange(packageIdentity.Version),
testNuGetProjectContext,
installationContext : null,
token : token);
await buildIntegratedProject.InstallPackageAsync(
packageIdentity2.Id,
new VersionRange(packageIdentity2.Version),
testNuGetProjectContext,
installationContext : null,
token : token);
// Act
await buildIntegratedProject.UninstallPackageAsync(packageIdentity2, new TestNuGetProjectContext(), CancellationToken.None);
await buildIntegratedProject.UninstallPackageAsync(packageIdentity, new TestNuGetProjectContext(), CancellationToken.None);
}
// Assert
// Check that the packages.config file exists after the installation
Assert.True(File.Exists(randomConfig));
// Check the number of packages and packages returned by project after the installation
var installedPackages = (await buildIntegratedProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(0, installedPackages.Count);
}
}
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 async Task TestGetMissingPackagesForSolution()
{
// Arrange
using (var testSolutionManager = new TestSolutionManager(true))
using (var randomPackageSourcePath = TestFileSystemUtility.CreateRandomTestFolder())
{
var projectA = testSolutionManager.AddNewMSBuildProject();
var projectB = testSolutionManager.AddNewMSBuildProject();
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage(randomPackageSourcePath,
packageIdentity.Id, packageIdentity.Version.ToNormalizedString());
var testNuGetProjectContext = new TestNuGetProjectContext();
var token = CancellationToken.None;
using (var packageStream = GetDownloadResult(packageFileInfo))
{
// Act
await projectA.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token);
await projectB.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token);
}
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var testSettings = Configuration.NullSettings.Instance;
var deleteOnRestartManager = new TestDeleteOnRestartManager();
var packageRestoreManager = new PackageRestoreManager(
sourceRepositoryProvider,
testSettings,
testSolutionManager);
// Act
var packagesFromSolution = (await packageRestoreManager.GetPackagesInSolutionAsync(testSolutionManager.SolutionDirectory, token));
var packagesFromSolutionList = packagesFromSolution.ToList();
var missingPackagesFromSolutionList = packagesFromSolution.Where(p => p.IsMissing).ToList();
Assert.Equal(1, packagesFromSolutionList.Count);
Assert.Equal(0, missingPackagesFromSolutionList.Count);
// Delete packages folder
TestFileSystemUtility.DeleteRandomTestFolder(Path.Combine(testSolutionManager.SolutionDirectory, "packages"));
packagesFromSolution = (await packageRestoreManager.GetPackagesInSolutionAsync(testSolutionManager.SolutionDirectory, token));
packagesFromSolutionList = packagesFromSolution.ToList();
missingPackagesFromSolutionList = packagesFromSolution.Where(p => p.IsMissing).ToList();
Assert.Equal(1, missingPackagesFromSolutionList.Count);
}
}
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));
}
}
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 async Task CopyNupkgToStreamAsync_TimeoutOnFirstAttempt_FileSizeCorrectAfterRetry()
{
// Arrange
// First create a mock package source with a package we can download
using TestDirectory testDirectory = TestDirectory.Create();
var packages = new List <string>();
const string packageId = "packageId";
const string packageVersionString = "1.0.0";
FileInfo packageFileInfo = TestPackagesGroupedByFolder.GetLargePackage(testDirectory, packageId, packageVersionString);
packages.Add(packageFileInfo.FullName);
// Make sure it's the package source that times out every second nupkg download attempt
NupkgDownloadTimeoutHttpClientHandler timeoutHandler = new NupkgDownloadTimeoutHttpClientHandler(packages);
var source = MockSourceRepository.Create(timeoutHandler);
// Now arrange the NuGet Client SDK experience
var protocolResource = await source.GetResourceAsync <FindPackageByIdResource>();
using (var destination = new MemoryStream())
{
var scc = new SourceCacheContext()
{
DirectDownload = true,
NoCache = true
};
NuGetVersion packageVersion = NuGetVersion.Parse(packageVersionString);
// Act
var result = await protocolResource.CopyNupkgToStreamAsync(packageId, packageVersion, destination, scc, NullLogger.Instance, CancellationToken.None);
// Assert
Assert.True(result);
Assert.Equal(1, timeoutHandler.FailedDownloads);
Assert.Equal(packageFileInfo.Length, destination.Length);
}
}
public async Task Test_PackageRestoreFailure_WithRaisedEvents()
{
// Arrange
using (var testSolutionManager = new TestSolutionManager(true))
using (var randomTestPackageSourcePath = TestFileSystemUtility.CreateRandomTestFolder())
{
var projectA = testSolutionManager.AddNewMSBuildProject("projectA");
var projectB = testSolutionManager.AddNewMSBuildProject("projectB");
var projectC = testSolutionManager.AddNewMSBuildProject("projectC");
var jQuery144 = Packages[0];
var jQueryValidation = Packages[2];
var testNuGetProjectContext = new TestNuGetProjectContext();
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var testSettings = Configuration.NullSettings.Instance;
var resolutionContext = new ResolutionContext();
var token = CancellationToken.None;
var deleteOnRestartManager = new TestDeleteOnRestartManager();
var nuGetPackageManager = new NuGetPackageManager(
sourceRepositoryProvider,
testSettings,
testSolutionManager,
deleteOnRestartManager);
await nuGetPackageManager.InstallPackageAsync(projectA, jQueryValidation,
resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token);
await nuGetPackageManager.InstallPackageAsync(projectB, jQueryValidation,
resolutionContext, testNuGetProjectContext, sourceRepositoryProvider.GetRepositories().First(), null, token);
var testPackage1 = new PackageIdentity("package1A", new NuGetVersion("1.0.0"));
var testPackage2 = new PackageIdentity("package1B", new NuGetVersion("1.0.0"));
var packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage(randomTestPackageSourcePath,
testPackage1.Id, testPackage1.Version.ToNormalizedString());
using (var packageStream = GetDownloadResult(packageFileInfo))
{
// Act
await projectB.InstallPackageAsync(testPackage1, packageStream, testNuGetProjectContext, token);
await projectC.InstallPackageAsync(testPackage1, packageStream, testNuGetProjectContext, token);
}
packageFileInfo = TestPackagesGroupedByFolder.GetLegacyTestPackage(randomTestPackageSourcePath,
testPackage2.Id, testPackage2.Version.ToNormalizedString());
using (var packageStream = GetDownloadResult(packageFileInfo))
{
// Act
await projectA.InstallPackageAsync(testPackage2, packageStream, testNuGetProjectContext, token);
await projectC.InstallPackageAsync(testPackage2, packageStream, testNuGetProjectContext, token);
}
var packageRestoreManager = new PackageRestoreManager(
sourceRepositoryProvider,
testSettings,
testSolutionManager);
var restoredPackages = new List <PackageIdentity>();
packageRestoreManager.PackageRestoredEvent += delegate(object sender, PackageRestoredEventArgs args) { restoredPackages.Add(args.Package); };
var restoreFailedPackages = new ConcurrentDictionary <Packaging.PackageReference, IEnumerable <string> >(new PackageReferenceComparer());
packageRestoreManager.PackageRestoreFailedEvent += delegate(object sender, PackageRestoreFailedEventArgs args)
{
restoreFailedPackages.AddOrUpdate(args.RestoreFailedPackageReference,
args.ProjectNames,
(Packaging.PackageReference packageReference, IEnumerable <string> oldValue) => { return(oldValue); });
};
Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder(jQueryValidation));
// Delete packages folder
TestFileSystemUtility.DeleteRandomTestFolder(Path.Combine(testSolutionManager.SolutionDirectory, "packages"));
Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder(jQuery144));
Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder(jQueryValidation));
Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder(testPackage1));
Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder(testPackage2));
// Act
await packageRestoreManager.RestoreMissingPackagesInSolutionAsync(testSolutionManager.SolutionDirectory,
testNuGetProjectContext,
CancellationToken.None);
// Assert
Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder(jQuery144));
Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder(jQueryValidation));
Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder(testPackage1));
Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder(testPackage2));
Assert.Equal(4, restoredPackages.Count);
// The ordering is not guaranteed and can vary. Do not assert based on that
Assert.True(restoredPackages.Contains(jQuery144));
Assert.True(restoredPackages.Contains(jQueryValidation));
Assert.True(restoredPackages.Contains(testPackage1));
Assert.True(restoredPackages.Contains(testPackage2));
Assert.Equal(2, restoreFailedPackages.Count);
// The ordering is not guaranteed and can vary. Do not assert based on that
var restoreFailedPackageKeys = restoreFailedPackages.Keys;
var testPackage1Key = restoreFailedPackageKeys.Where(r => r.PackageIdentity.Equals(testPackage1)).First();
var testPackage1ProjectNames = restoreFailedPackages[testPackage1Key].ToList();
Assert.Equal(2, testPackage1ProjectNames.Count);
Assert.True(testPackage1ProjectNames.Contains("projectB", StringComparer.OrdinalIgnoreCase));
Assert.True(testPackage1ProjectNames.Contains("projectC", StringComparer.OrdinalIgnoreCase));
var testPackage2Key = restoreFailedPackageKeys.Where(r => r.PackageIdentity.Equals(testPackage2)).First();
var testPackage2ProjectNames = restoreFailedPackages[testPackage2Key].ToList();
Assert.Equal(2, testPackage2ProjectNames.Count);
Assert.True(testPackage2ProjectNames.Contains("projectA", StringComparer.OrdinalIgnoreCase));
Assert.True(testPackage2ProjectNames.Contains("projectC", StringComparer.OrdinalIgnoreCase));
}
}
