public async Task TestGetMissingPackagesForSolution_NoPackagesInstalled()
{
// Arrange
using (var testSolutionManager = new TestSolutionManager(true))
{
var projectA = testSolutionManager.AddNewMSBuildProject();
var projectB = testSolutionManager.AddNewMSBuildProject();
var testNuGetProjectContext = new TestNuGetProjectContext();
var token = CancellationToken.None;
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));
Assert.False(packagesFromSolution.Any());
}
}
public async Task TestUninstallLastPackage()
{
// Arrange
using (var randomTestFolder = TestDirectory.Create())
{
var targetFramework = NuGetFramework.Parse("net45");
var metadata = GetTestMetadata(targetFramework);
var packagesConfigNuGetProject = new PackagesConfigNuGetProject(randomTestFolder, metadata);
var packageIdentity = new PackageIdentity("A", new NuGetVersion("1.0.0"));
var testNuGetProjectContext = new TestNuGetProjectContext();
var token = CancellationToken.None;
MakeFileReadOnly(randomTestFolder);
// Act
await packagesConfigNuGetProject.InstallPackageAsync(packageIdentity, GetDownloadResourceResult(), testNuGetProjectContext, token);
MakeFileReadOnly(randomTestFolder);
// Assert
var installedPackagesList = (await packagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(1, installedPackagesList.Count);
Assert.Equal(packageIdentity, installedPackagesList[0].PackageIdentity);
Assert.Equal(targetFramework, installedPackagesList[0].TargetFramework);
// Main Act
await packagesConfigNuGetProject.UninstallPackageAsync(packageIdentity, testNuGetProjectContext, token);
// Main Assert
installedPackagesList = (await packagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(0, installedPackagesList.Count);
}
}
public NuGetProjectManagerServiceTests(GlobalServiceProvider globalServiceProvider)
: base(globalServiceProvider)
{
_projectContext = new TestNuGetProjectContext();
AddService <INuGetProjectContext>(Task.FromResult <object>(_projectContext));
}
public async Task TestBuildIntegratedNuGetPackageSpecNameMatchesFilePath()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", 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,
"msbuildName");
var projectFilePath = Path.Combine(randomProjectFolderPath, "fileName.csproj");
var buildIntegratedProject = new ProjectJsonNuGetProject(randomConfig, projectFilePath);
var spec = await buildIntegratedProject.GetPackageSpecsAsync(new DependencyGraphCacheContext());
// Assert
Assert.Equal(projectFilePath, buildIntegratedProject.MSBuildProjectPath);
Assert.Equal("fileName", buildIntegratedProject.ProjectName);
Assert.Equal("fileName", spec.Single().Name);
}
}
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 void TestBuildIntegratedNuGetPackageSpecNameMatchesFilePath()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
using (var randomTestPackageSourcePath = TestFileSystemUtility.CreateRandomTestFolder())
using (var randomPackagesFolderPath = TestFileSystemUtility.CreateRandomTestFolder())
using (var randomProjectFolderPath = TestFileSystemUtility.CreateRandomTestFolder())
{
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,
"msbuildName");
var projectFilePath = Path.Combine(randomProjectFolderPath, "fileName.csproj");
var buildIntegratedProject = new BuildIntegratedNuGetProject(randomConfig, projectFilePath, msBuildNuGetProjectSystem);
// Assert
Assert.Equal(projectFilePath, buildIntegratedProject.MSBuildProjectPath);
Assert.Equal("fileName", buildIntegratedProject.ProjectName);
Assert.Equal("fileName", buildIntegratedProject.PackageSpec.Name);
}
}
public async Task TestPackageRestoredEvent()
{
// Arrange
using (var testSolutionManager = new TestSolutionManager(true))
{
var projectA = testSolutionManager.AddNewMSBuildProject();
var projectB = testSolutionManager.AddNewMSBuildProject();
var packageIdentity = Packages[0];
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, 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
TestFileSystemUtility.DeleteRandomTestFolder(Path.Combine(testSolutionManager.SolutionDirectory, "packages"));
Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity)));
// Act
await packageRestoreManager.RestoreMissingPackagesInSolutionAsync(testSolutionManager.SolutionDirectory,
testNuGetProjectContext,
new TestLogger(),
CancellationToken.None);
Assert.Equal(1, restoredPackages.Count);
Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity)));
}
}
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 NuGetProjectManagerServiceTests(GlobalServiceProvider globalServiceProvider)
: base(globalServiceProvider)
{
_projectContext = new TestNuGetProjectContext();
var componentModel = new Mock <IComponentModel>();
componentModel.Setup(x => x.GetService <INuGetProjectContext>()).Returns(_projectContext);
AddService <SComponentModel>(Task.FromResult((object)componentModel.Object));
}
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 BuildIntegratedNuGetProject_GetPackageSpec_UAPWithImports()
{
// Arrange
var configJson = @"
{
""dependencies"": {
},
""frameworks"": {
""uap10.0"": {
""imports"": ""netstandard1.3"",
""warn"": false
}
}
}";
using (var randomProjectFolderPath = TestDirectory.Create())
{
var projectJsonPath = Path.Combine(randomProjectFolderPath, "project.json");
File.WriteAllText(projectJsonPath, configJson);
var FallbackTargetFramework = NuGetFramework.Parse("netstandard1.3");
var projectTargetFramework = NuGetFramework.Parse("uap10.0");
var testNuGetProjectContext = new TestNuGetProjectContext();
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, testNuGetProjectContext, randomProjectFolderPath);
var projectFilePath = Path.Combine(randomProjectFolderPath, $"{msBuildNuGetProjectSystem.ProjectName}.csproj");
var buildIntegratedProject = new ProjectJsonNuGetProject(projectJsonPath, projectFilePath);
var referenceContext = new DependencyGraphCacheContext(new TestLogger(), NullSettings.Instance);
// Act
var actual = (await buildIntegratedProject.GetPackageSpecsAsync(referenceContext)).SingleOrDefault();
// Assert
Assert.NotNull(actual);
Assert.Equal(msBuildNuGetProjectSystem.ProjectName, actual.Name);
Assert.Equal(projectJsonPath, actual.FilePath);
Assert.NotNull(actual.RestoreMetadata);
Assert.Equal(ProjectStyle.ProjectJson, actual.RestoreMetadata.ProjectStyle);
Assert.Equal(projectFilePath, actual.RestoreMetadata.ProjectPath);
Assert.Equal(msBuildNuGetProjectSystem.ProjectName, actual.RestoreMetadata.ProjectName);
Assert.Equal(projectFilePath, actual.RestoreMetadata.ProjectUniqueName);
Assert.Equal(1, actual.TargetFrameworks.Count);
Assert.Equal(projectTargetFramework, actual.TargetFrameworks[0].FrameworkName);
Assert.Equal(1, actual.TargetFrameworks[0].Imports.Count);
Assert.Equal(FallbackTargetFramework, actual.TargetFrameworks[0].Imports[0]);
Assert.Empty(actual.Dependencies);
Assert.Empty(actual.TargetFrameworks[0].Dependencies);
Assert.Empty(actual.RestoreMetadata.TargetFrameworks.SelectMany(e => e.ProjectReferences));
}
}
public async Task TestUninstallPenultimatePackage()
{
// Arrange
var randomTestFolder = TestFilesystemUtility.CreateRandomTestFolder();
var packagesConfigFileName = "packages.config";
var targetFramework = NuGetFramework.Parse("net45");
var metadata = new Dictionary <string, object>()
{
{ NuGetProjectMetadataKeys.TargetFramework, targetFramework },
};
var packagesConfigFullPath = Path.Combine(randomTestFolder, packagesConfigFileName);
var packagesConfigNuGetProject = new PackagesConfigNuGetProject(packagesConfigFullPath, metadata);
var packageA = new PackageIdentity("A", new NuGetVersion("1.0.0"));
var packageB = new PackageIdentity("B", new NuGetVersion("1.0.0"));
var testNuGetProjectContext = new TestNuGetProjectContext();
var token = CancellationToken.None;
MakeFileReadOnly(packagesConfigFullPath);
// Act
await packagesConfigNuGetProject.InstallPackageAsync(packageA, Stream.Null, testNuGetProjectContext, token);
MakeFileReadOnly(packagesConfigFullPath);
// Assert
var installedPackagesList = (await packagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(1, installedPackagesList.Count);
Assert.Equal(packageA, installedPackagesList[0].PackageIdentity);
Assert.Equal(targetFramework, installedPackagesList[0].TargetFramework);
// Act
await packagesConfigNuGetProject.InstallPackageAsync(packageB, Stream.Null, testNuGetProjectContext, token);
// Assert
installedPackagesList = (await packagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(2, installedPackagesList.Count);
Assert.Equal(packageA, installedPackagesList[0].PackageIdentity);
Assert.Equal(packageB, installedPackagesList[1].PackageIdentity);
Assert.Equal(targetFramework, installedPackagesList[0].TargetFramework);
Assert.Equal(targetFramework, installedPackagesList[1].TargetFramework);
// Main Act
await packagesConfigNuGetProject.UninstallPackageAsync(packageA, testNuGetProjectContext, token);
// Main Assert
installedPackagesList = (await packagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(1, installedPackagesList.Count);
Assert.Equal(packageB, installedPackagesList[0].PackageIdentity);
Assert.Equal(targetFramework, installedPackagesList[0].TargetFramework);
}
public TestInfo(string projectFileContent, string projectName = "proj1")
{
ProjectDirectory = TestDirectory.Create();
MSBuildDirectory = MsBuildUtility.GetMsBuildDirectory(null, null);
NuGetProjectContext = new TestNuGetProjectContext();
var projectFilePath = Path.Combine(ProjectDirectory, projectName + ".csproj");
File.WriteAllText(projectFilePath, projectFileContent);
MSBuildProjectSystem
= new MSBuildProjectSystem(MSBuildDirectory, projectFilePath, NuGetProjectContext);
}
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 NuGetProjectManagerServiceTests(DispatcherThreadFixture dispatcherThreadFixture)
{
Assert.NotNull(dispatcherThreadFixture);
_projectContext = new TestNuGetProjectContext();
_services = new Dictionary <Type, Task <object> >()
{
{ typeof(INuGetProjectContext), Task.FromResult <object>(_projectContext) }
};
ServiceLocator.InitializePackageServiceProvider(this);
NuGetUIThreadHelper.SetCustomJoinableTaskFactory(dispatcherThreadFixture.JoinableTaskFactory);
}
internal async Task InstallAsync(PackageSaveMode packageSaveMode)
{
using (var result = GetDownloadResourceResult(Package))
{
var projectContext = new TestNuGetProjectContext();
projectContext.PackageExtractionContext.PackageSaveMode = packageSaveMode;
await Project.InstallPackageAsync(
PackageIdentity,
result,
projectContext,
CancellationToken.None);
}
}
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));
}
}
public TestInfo(ITestOutputHelper testOutputHelper, string projectFileContent, string projectName = "proj1")
{
var console = new Mock <IConsole>();
console.Setup(c => c.WriteLine(It.IsAny <string>(), It.IsAny <object[]>())).Callback <string, object[]>((format, args) => testOutputHelper.WriteLine(format, args));
console.SetupGet(c => c.Verbosity).Returns(Verbosity.Detailed);
_projectDirectory = TestDirectory.Create();
_msBuildDirectory = MsBuildUtility.GetMsBuildToolset(null, console.Object).Path;
_nuGetProjectContext = new TestNuGetProjectContext();
var projectFilePath = Path.Combine(_projectDirectory, projectName + ".csproj");
File.WriteAllText(projectFilePath, projectFileContent);
MSBuildProjectSystem
= new MSBuildProjectSystem(_msBuildDirectory, projectFilePath, _nuGetProjectContext);
}
public async Task TestFolderNuGetProjectGetInstalledPackageFilePath()
{
// Arrange
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
var randomTestSourcePath = TestFilesystemUtility.CreateRandomTestFolder();
var packageFileInfo = TestPackages.GetLegacyTestPackage(randomTestSourcePath, packageIdentity.Id, packageIdentity.Version.ToNormalizedString());
var randomTestDestinationPath = TestFilesystemUtility.CreateRandomTestFolder();
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 = packageFileInfo.OpenRead())
{
// 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);
}
// Main Act
var installedPackageFilePath = folderNuGetProject.GetInstalledPackageFilePath(new PackageIdentity(packageIdentity.Id,
new NuGetVersion(packageIdentity.Version + ".0")));
// Assert
Assert.NotNull(installedPackageFilePath);
Assert.True(File.Exists(installedPackageFilePath));
Assert.True(String.Equals(nupkgFilePath, installedPackageFilePath));
// Clean-up
TestFilesystemUtility.DeleteRandomTestFolders(randomTestSourcePath, randomTestDestinationPath);
}
public async Task TestGetMissingPackagesForSolution()
{
// Arrange
var testSolutionManager = new TestSolutionManager();
var projectA = testSolutionManager.AddNewMSBuildProject();
var projectB = testSolutionManager.AddNewMSBuildProject();
var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0"));
var randomPackageSourcePath = TestFilesystemUtility.CreateRandomTestFolder();
var packageFileInfo = TestPackages.GetLegacyTestPackage(randomPackageSourcePath,
packageIdentity.Id, packageIdentity.Version.ToNormalizedString());
var testNuGetProjectContext = new TestNuGetProjectContext();
var token = CancellationToken.None;
using (var packageStream = packageFileInfo.OpenRead())
{
// Act
await projectA.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token);
await projectB.InstallPackageAsync(packageIdentity, packageStream, testNuGetProjectContext, token);
}
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var testSettings = NullSettings.Instance;
var packageRestoreManager = new PackageRestoreManager(sourceRepositoryProvider, testSettings, testSolutionManager);
// Act
var packageReferencesFromSolution = (await packageRestoreManager.GetPackageReferencesFromSolution(token)).ToList();
var missingPackagesFromSolution = (await packageRestoreManager.GetMissingPackagesInSolution(token)).ToList();
Assert.Equal(2, packageReferencesFromSolution.Count);
Assert.Equal(0, missingPackagesFromSolution.Count);
// Delete packages folder
Directory.Delete(Path.Combine(testSolutionManager.SolutionDirectory, "packages"), recursive: true);
packageReferencesFromSolution = (await packageRestoreManager.GetPackageReferencesFromSolution(token)).ToList();
missingPackagesFromSolution = (await packageRestoreManager.GetMissingPackagesInSolution(token)).ToList();
Assert.Equal(2, packageReferencesFromSolution.Count);
Assert.Equal(1, missingPackagesFromSolution.Count);
}
public async Task BuildIntegratedNuGetProject_GetPackageSpecForRestore_NoReferences()
{
// Arrange
using (var randomProjectFolderPath = TestDirectory.Create())
{
var projectJsonPath = Path.Combine(randomProjectFolderPath, "project.json");
CreateConfigJson(projectJsonPath);
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(projectJsonPath, projectFilePath);
var referenceContext = new DependencyGraphCacheContext(new TestLogger(), NullSettings.Instance);
// Act
var actual = (await buildIntegratedProject.GetPackageSpecsAsync(referenceContext)).SingleOrDefault();
// Assert
Assert.NotNull(actual);
Assert.Equal(msBuildNuGetProjectSystem.ProjectName, actual.Name);
Assert.Equal(projectJsonPath, actual.FilePath);
Assert.NotNull(actual.RestoreMetadata);
Assert.Equal(ProjectStyle.ProjectJson, actual.RestoreMetadata.ProjectStyle);
Assert.Equal(projectFilePath, actual.RestoreMetadata.ProjectPath);
Assert.Equal(msBuildNuGetProjectSystem.ProjectName, actual.RestoreMetadata.ProjectName);
Assert.Equal(projectFilePath, actual.RestoreMetadata.ProjectUniqueName);
Assert.Equal(1, actual.TargetFrameworks.Count);
Assert.Equal(projectTargetFramework, actual.TargetFrameworks[0].FrameworkName);
Assert.Empty(actual.TargetFrameworks[0].Imports);
Assert.Empty(actual.Dependencies);
Assert.Empty(actual.TargetFrameworks[0].Dependencies);
Assert.Empty(actual.RestoreMetadata.TargetFrameworks.SelectMany(e => e.ProjectReferences));
}
}
public async Task TestRestoreMissingPackages()
{
// 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);
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.True(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity)));
}
public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_PackageShaValidationFailed()
{
using (var packageSource = TestDirectory.Create())
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(
new List <Configuration.PackageSource>()
{
new Configuration.PackageSource(packageSource.Path)
});
using (var testSolutionManager = new TestSolutionManager(true))
using (var randomProjectFolderPath = TestDirectory.Create())
{
var testSettings = PopulateSettingsWithSources(sourceRepositoryProvider, randomProjectFolderPath);
var testNuGetProjectContext = new TestNuGetProjectContext();
var deleteOnRestartManager = new TestDeleteOnRestartManager();
var nuGetPackageManager = new NuGetPackageManager(
sourceRepositoryProvider,
testSettings,
testSolutionManager,
deleteOnRestartManager);
var projectTargetFrameworkStr = "net45";
var fullProjectPath = Path.Combine(randomProjectFolderPath, "project1.csproj");
var projectNames = new ProjectNames(
fullName: fullProjectPath,
uniqueName: Path.GetFileName(fullProjectPath),
shortName: Path.GetFileNameWithoutExtension(fullProjectPath),
customUniqueName: Path.GetFileName(fullProjectPath));
var vsProjectAdapter = new TestVSProjectAdapter(
fullProjectPath,
projectNames,
projectTargetFrameworkStr);
var projectServices = new TestProjectSystemServices();
projectServices.SetupInstalledPackages(
NuGetFramework.Parse(projectTargetFrameworkStr),
new LibraryDependency
{
LibraryRange = new LibraryRange(
"packageA",
VersionRange.Parse("1.*"),
LibraryDependencyTarget.Package)
});
var legacyPRProject = new LegacyPackageReferenceProject(
vsProjectAdapter,
Guid.NewGuid().ToString(),
projectServices,
_threadingService);
testSolutionManager.NuGetProjects.Add(legacyPRProject);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger, testSettings);
var packageContext = new SimpleTestPackageContext("packageA", "1.0.0");
packageContext.AddFile("lib/net45/a.dll");
SimpleTestPackageUtility.CreateOPCPackage(packageContext, packageSource);
var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(testSolutionManager, restoreContext);
var projectLockFilePath = Path.Combine(randomProjectFolderPath, "packages.project1.lock.json");
File.Create(projectLockFilePath).Close();
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
testSolutionManager,
dgSpec,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sourceRepositoryProvider.GetRepositories(),
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
foreach (var restoreSummary in restoreSummaries)
{
Assert.True(restoreSummary.Success);
Assert.False(restoreSummary.NoOpRestore);
}
Assert.True(File.Exists(projectLockFilePath));
// delete existing restore output files
File.Delete(Path.Combine(vsProjectAdapter.MSBuildProjectExtensionsPath, "project.assets.json"));
File.Delete(Path.Combine(vsProjectAdapter.MSBuildProjectExtensionsPath, "project1.csproj.nuget.cache"));
// clean packages folder
var packagesFolder = Path.Combine(randomProjectFolderPath, "packages");
Directory.Delete(packagesFolder, true);
Directory.CreateDirectory(packagesFolder);
// add a new package
var newPackageContext = new SimpleTestPackageContext("packageA", "1.0.0");
newPackageContext.AddFile("lib/net45/a1.dll");
SimpleTestPackageUtility.CreateOPCPackage(newPackageContext, packageSource);
// Act
restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
testSolutionManager,
dgSpec,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sourceRepositoryProvider.GetRepositories(),
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
// Assert
foreach (var restoreSummary in restoreSummaries)
{
Assert.False(restoreSummary.Success);
Assert.True(restoreSummary.Errors.Count > 0);
Assert.NotNull(restoreSummary.Errors.FirstOrDefault(message => (message as RestoreLogMessage).Code == NuGetLogCode.NU1403));
}
}
}
}
public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_LockedMode()
{
using (var packageSource = TestDirectory.Create())
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(
new List <Configuration.PackageSource>()
{
new Configuration.PackageSource(packageSource.Path)
});
using (var testSolutionManager = new TestSolutionManager(true))
using (var randomProjectFolderPath = TestDirectory.Create())
{
var testSettings = PopulateSettingsWithSources(sourceRepositoryProvider, randomProjectFolderPath);
var testNuGetProjectContext = new TestNuGetProjectContext();
var deleteOnRestartManager = new TestDeleteOnRestartManager();
var nuGetPackageManager = new NuGetPackageManager(
sourceRepositoryProvider,
testSettings,
testSolutionManager,
deleteOnRestartManager);
var projectTargetFrameworkStr = "net45";
var fullProjectPath = Path.Combine(randomProjectFolderPath, "project1.csproj");
var projectNames = new ProjectNames(
fullName: fullProjectPath,
uniqueName: Path.GetFileName(fullProjectPath),
shortName: Path.GetFileNameWithoutExtension(fullProjectPath),
customUniqueName: Path.GetFileName(fullProjectPath));
var vsProjectAdapter = new TestVSProjectAdapter(
fullProjectPath,
projectNames,
projectTargetFrameworkStr,
restorePackagesWithLockFile: "true",
restoreLockedMode: true);
var projectServices = new TestProjectSystemServices();
projectServices.SetupInstalledPackages(
NuGetFramework.Parse(projectTargetFrameworkStr),
new LibraryDependency
{
LibraryRange = new LibraryRange(
"packageA",
VersionRange.Parse("1.*"),
LibraryDependencyTarget.Package)
});
var legacyPRProject = new LegacyPackageReferenceProject(
vsProjectAdapter,
Guid.NewGuid().ToString(),
projectServices,
_threadingService);
testSolutionManager.NuGetProjects.Add(legacyPRProject);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger, testSettings);
var packageContextA = new SimpleTestPackageContext("packageA", "1.0.0");
packageContextA.AddFile("lib/net45/a.dll");
SimpleTestPackageUtility.CreateOPCPackage(packageContextA, packageSource);
var packageContextB = new SimpleTestPackageContext("packageB", "1.0.0");
packageContextB.AddFile("lib/net45/b.dll");
SimpleTestPackageUtility.CreateOPCPackage(packageContextB, packageSource);
var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(testSolutionManager, restoreContext);
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
testSolutionManager,
dgSpec,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sourceRepositoryProvider.GetRepositories(),
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
foreach (var restoreSummary in restoreSummaries)
{
Assert.True(restoreSummary.Success);
Assert.False(restoreSummary.NoOpRestore);
}
Assert.True(File.Exists(Path.Combine(randomProjectFolderPath, "packages.lock.json")));
// install a new package
projectServices.SetupInstalledPackages(
NuGetFramework.Parse(projectTargetFrameworkStr),
new LibraryDependency
{
LibraryRange = new LibraryRange(
"packageA",
VersionRange.Parse("1.*"),
LibraryDependencyTarget.Package)
},
new LibraryDependency
{
LibraryRange = new LibraryRange(
"packageB",
VersionRange.Parse("1.0.0"),
LibraryDependencyTarget.Package)
});
// update the proeject with new ProjectService instance
restoreContext.PackageSpecCache.Clear();
dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(testSolutionManager, restoreContext);
// Act
restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
testSolutionManager,
dgSpec,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sourceRepositoryProvider.GetRepositories(),
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
// Assert
foreach (var restoreSummary in restoreSummaries)
{
Assert.False(restoreSummary.Success);
}
}
}
}
public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_GenerateLockFile()
{
using (var packageSource = TestDirectory.Create())
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(
new List <Configuration.PackageSource>()
{
new Configuration.PackageSource(packageSource.Path)
});
using (var testSolutionManager = new TestSolutionManager(true))
using (var randomProjectFolderPath = TestDirectory.Create())
{
var testSettings = PopulateSettingsWithSources(sourceRepositoryProvider, randomProjectFolderPath);
var testNuGetProjectContext = new TestNuGetProjectContext();
var deleteOnRestartManager = new TestDeleteOnRestartManager();
var nuGetPackageManager = new NuGetPackageManager(
sourceRepositoryProvider,
testSettings,
testSolutionManager,
deleteOnRestartManager);
// set up projects
var projectTargetFrameworkStr = "net45";
var fullProjectPathB = Path.Combine(randomProjectFolderPath, "ProjectB", "project2.csproj");
var projectNamesB = new ProjectNames(
fullName: fullProjectPathB,
uniqueName: Path.GetFileName(fullProjectPathB),
shortName: Path.GetFileNameWithoutExtension(fullProjectPathB),
customUniqueName: Path.GetFileName(fullProjectPathB));
var vsProjectAdapterB = new TestVSProjectAdapter(
fullProjectPathB,
projectNamesB,
projectTargetFrameworkStr);
var projectServicesB = new TestProjectSystemServices();
projectServicesB.SetupInstalledPackages(
NuGetFramework.Parse(projectTargetFrameworkStr),
new LibraryDependency
{
LibraryRange = new LibraryRange(
"packageB",
VersionRange.Parse("1.*"),
LibraryDependencyTarget.Package)
});
var legacyPRProjectB = new LegacyPackageReferenceProject(
vsProjectAdapterB,
Guid.NewGuid().ToString(),
projectServicesB,
_threadingService);
var projectPathA = Path.Combine(randomProjectFolderPath, "ProjectA");
var fullProjectPathA = Path.Combine(projectPathA, "project1.csproj");
var projectNamesA = new ProjectNames(
fullName: fullProjectPathA,
uniqueName: Path.GetFileName(fullProjectPathA),
shortName: Path.GetFileNameWithoutExtension(fullProjectPathA),
customUniqueName: Path.GetFileName(fullProjectPathA));
var vsProjectAdapterA = new TestVSProjectAdapter(
fullProjectPathA,
projectNamesA,
projectTargetFrameworkStr,
restorePackagesWithLockFile: "true");
var projectServicesA = new TestProjectSystemServices();
projectServicesA.SetupInstalledPackages(
NuGetFramework.Parse(projectTargetFrameworkStr),
new LibraryDependency
{
LibraryRange = new LibraryRange(
"packageA",
VersionRange.Parse("1.*"),
LibraryDependencyTarget.Package)
});
projectServicesA.SetupProjectDependencies(
new ProjectRestoreReference
{
ProjectUniqueName = fullProjectPathB,
ProjectPath = fullProjectPathB
});
var legacyPRProjectA = new LegacyPackageReferenceProject(
vsProjectAdapterA,
Guid.NewGuid().ToString(),
projectServicesA,
_threadingService);
testSolutionManager.NuGetProjects.Add(legacyPRProjectB);
testSolutionManager.NuGetProjects.Add(legacyPRProjectA);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger, testSettings);
var providersCache = new RestoreCommandProvidersCache();
var packageContextA = new SimpleTestPackageContext("packageA", "1.0.0");
packageContextA.AddFile("lib/net45/a.dll");
var packageContextB = new SimpleTestPackageContext("packageB", "1.0.0");
packageContextB.AddFile("lib/net45/b.dll");
var packages = new List <SimpleTestPackageContext>()
{
packageContextA, packageContextB
};
SimpleTestPackageUtility.CreateOPCPackages(packages, packageSource);
var dgSpec = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(testSolutionManager, restoreContext);
// Act
var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
testSolutionManager,
dgSpec,
restoreContext,
providersCache,
(c) => { },
sourceRepositoryProvider.GetRepositories(),
Guid.Empty,
false,
true,
testLogger,
CancellationToken.None);
// Assert
foreach (var restoreSummary in restoreSummaries)
{
Assert.True(restoreSummary.Success);
Assert.False(restoreSummary.NoOpRestore);
}
Assert.True(File.Exists(Path.Combine(projectPathA, "packages.lock.json")));
var lockFile = PackagesLockFileFormat.Read(Path.Combine(projectPathA, "packages.lock.json"));
Assert.Equal(1, lockFile.Targets.Count);
Assert.Equal(".NETFramework,Version=v4.5", lockFile.Targets[0].Name);
Assert.Equal(3, lockFile.Targets[0].Dependencies.Count);
Assert.Equal("packageA", lockFile.Targets[0].Dependencies[0].Id);
Assert.Equal(PackageDependencyType.Direct, lockFile.Targets[0].Dependencies[0].Type);
Assert.Equal("packageB", lockFile.Targets[0].Dependencies[1].Id);
Assert.Equal(PackageDependencyType.Transitive, lockFile.Targets[0].Dependencies[1].Type);
Assert.Equal("project2", lockFile.Targets[0].Dependencies[2].Id);
Assert.Equal(PackageDependencyType.Project, lockFile.Targets[0].Dependencies[2].Type);
}
}
}
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));
}
}
