public SharedServiceStateTests(GlobalServiceProvider globalServiceProvider)
: base(globalServiceProvider)
{
var solutionManager = new Mock <IVsSolutionManager>();
solutionManager.SetupGet(x => x.SolutionDirectory)
.Returns(@"C:\a");
SourceRepositoryProvider sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
AddService <IDeleteOnRestartManager>(Task.FromResult <object>(Mock.Of <IDeleteOnRestartManager>()));
AddService <ISettings>(Task.FromResult <object>(Mock.Of <ISettings>()));
AddService <ISourceRepositoryProvider>(Task.FromResult <object>(sourceRepositoryProvider));
AddService <IVsSolutionManager>(Task.FromResult <object>(solutionManager.Object));
}
public async Task UnzippedPackageInstall_Basic()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
using (var testSolutionManager = new TestSolutionManager(true))
using (var randomPackagesConfigFolderPath = TestDirectory.Create())
{
var testSettings = new Configuration.NullSettings();
var deleteOnRestartManager = new TestDeleteOnRestartManager();
var nuGetPackageManager = new NuGetPackageManager(
sourceRepositoryProvider,
testSettings,
testSolutionManager,
deleteOnRestartManager);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config");
var token = CancellationToken.None;
var projectTargetFramework = NuGetFramework.Parse("net45");
var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext());
var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigFolderPath);
var packageIdentity = NoDependencyLibPackages[0];
// Pre-Assert
// Check that the packages.config file does not exist
Assert.False(File.Exists(randomPackagesConfigPath));
// Check that there are no packages returned by PackagesConfigProject
var packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(0, packagesInPackagesConfig.Count);
Assert.Equal(0, msBuildNuGetProjectSystem.References.Count);
// Act
await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, packageIdentity,
new ResolutionContext(), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
// Check that the packages.config file exists after the installation
Assert.True(File.Exists(randomPackagesConfigPath));
// Check the number of packages and packages returned by PackagesConfigProject after the installation
packagesInPackagesConfig = (await msBuildNuGetProject.PackagesConfigNuGetProject.GetInstalledPackagesAsync(token)).ToList();
Assert.Equal(1, packagesInPackagesConfig.Count);
Assert.Equal(packageIdentity, packagesInPackagesConfig[0].PackageIdentity);
Assert.Equal(projectTargetFramework, packagesInPackagesConfig[0].TargetFramework);
}
}
public async Task TestRestoreMissingPackages()
{
// 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);
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.True(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity)));
}
}
public async Task TestPackageRestoredEvent()
{
// Arrange
var testSolutionManager = new TestSolutionManager();
var projectA = testSolutionManager.AddNewMSBuildProject();
var projectB = testSolutionManager.AddNewMSBuildProject();
var packageIdentity = Packages[0];
var testNuGetProjectContext = new TestNuGetProjectContext();
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var testSettings = NullSettings.Instance;
var resolutionContext = new ResolutionContext();
var token = CancellationToken.None;
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, testSettings, testSolutionManager);
await nuGetPackageManager.InstallPackageAsync(projectA, packageIdentity,
resolutionContext, new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token);
await nuGetPackageManager.InstallPackageAsync(projectB, packageIdentity,
resolutionContext, new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token);
var packageRestoreManager = new PackageRestoreManager(sourceRepositoryProvider, testSettings, testSolutionManager);
var restoredPackages = new List <PackageIdentity>();
packageRestoreManager.PackageRestoredEvent += delegate(object sender, PackageRestoredEventArgs args)
{
if (args.Restored)
{
restoredPackages.Add(args.Package);
}
};
Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder(packageIdentity));
// Delete packages folder
Directory.Delete(Path.Combine(testSolutionManager.SolutionDirectory, "packages"), recursive: true);
Assert.False(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity)));
// Act
await packageRestoreManager.RestoreMissingPackagesInSolutionAsync(CancellationToken.None);
Assert.Equal(1, restoredPackages.Count);
Assert.True(nuGetPackageManager.PackageExistsInPackagesFolder((packageIdentity)));
}
public async Task Simple_ReportsNoOp_Async()
{
var restoreMan = Mock.Of <IPackageRestoreManager>();
_globalProvider.AddService(typeof(IPackageRestoreManager), restoreMan);
var slnMan = Mock.Of <IVsSolutionManager>();
_globalProvider.AddService(typeof(IVsSolutionManager), slnMan);
ISourceRepositoryProvider sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
_globalProvider.AddService(typeof(ISourceRepositoryProvider), sourceRepositoryProvider);
var restoreChecker = Mock.Of <ISolutionRestoreChecker>();
var eventsPublisher = Mock.Of <IRestoreEventsPublisher>();
var settings = Mock.Of <ISettings>();
Mock.Get(settings)
.Setup(x => x.GetSection("packageRestore"))
.Returns(() => new VirtualSettingSection("packageRestore",
new AddItem("automatic", bool.TrueString)));
var consoleProvider = Mock.Of <IOutputConsoleProvider>();
var logger = new RestoreOperationLogger(new Lazy <IOutputConsoleProvider>(() => consoleProvider));
var job = new SolutionRestoreJob(
asyncServiceProvider: AsyncServiceProvider.GlobalProvider,
packageRestoreManager: restoreMan,
solutionManager: slnMan,
sourceRepositoryProvider: sourceRepositoryProvider,
restoreEventsPublisher: eventsPublisher,
settings: settings,
solutionRestoreChecker: restoreChecker);
var restoreRequest = new SolutionRestoreRequest(
forceRestore: true,
RestoreOperationSource.OnBuild);
var restoreJobContext = new SolutionRestoreJobContext();
await job.ExecuteAsync(
request : restoreRequest,
jobContext : restoreJobContext,
logger : logger,
isSolutionLoadRestore : true,
token : CancellationToken.None);
Assert.Equal(NuGetOperationStatus.NoOp, job.Status);
}
public async Task TestDownloadPackage_MultipleSources_NotFound()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[]
{
new Configuration.PackageSource("https://www.myget.org/F/aspnetvnext/api/v2/"),
new Configuration.PackageSource("http://blah.com"),
});
var packageIdentity = new PackageIdentity("jQuery", new NuGetVersion("1.8.2"));
await Assert.ThrowsAsync <FatalProtocolException>(async() => await PackageDownloader.GetDownloadResourceResultAsync(sourceRepositoryProvider.GetRepositories(),
packageIdentity,
Configuration.NullSettings.Instance,
Common.NullLogger.Instance,
CancellationToken.None));
}
public async Task DoNotCreateLockFileWhenFeatureDisabled()
{
// Arrange
using (var packageSource = TestDirectory.Create())
using (var testSolutionManager = new TestSolutionManager())
{
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(
new List <PackageSource>()
{
new PackageSource(packageSource.Path)
});
var testSettings = NullSettings.Instance;
var token = CancellationToken.None;
var deleteOnRestartManager = new TestDeleteOnRestartManager();
var nuGetPackageManager = new NuGetPackageManager(
sourceRepositoryProvider,
testSettings,
testSolutionManager,
deleteOnRestartManager);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings);
var packageContext = new SimpleTestPackageContext("packageA");
packageContext.AddFile("lib/net45/a.dll");
SimpleTestPackageUtility.CreateOPCPackage(packageContext, packageSource);
var msBuildNuGetProject = testSolutionManager.AddNewMSBuildProject();
var msBuildNuGetProjectSystem = msBuildNuGetProject.ProjectSystem as TestMSBuildNuGetProjectSystem;
msBuildNuGetProjectSystem.SetPropertyValue("RestorePackagesWithLockFile", "false");
var packagesConfigPath = msBuildNuGetProject.PackagesConfigNuGetProject.FullPath;
var packagesLockPath = packagesConfigPath.Replace("packages.config", "packages.lock.json");
var packageIdentity = packageContext.Identity;
// Pre-Assert
// Check that the packages.lock.json file does not exist
Assert.False(File.Exists(packagesLockPath));
// Act
await nuGetPackageManager.InstallPackageAsync(msBuildNuGetProject, packageIdentity,
new ResolutionContext(), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token);
// Assert
// Check that the packages.lock.json still does not exist after the installation
Assert.False(File.Exists(packagesLockPath));
}
}
public async Task GetTotalCountAsync_Works()
{
var uiContext = Mock.Of <INuGetUIContext>();
var source1 = new Configuration.PackageSource("https://dotnet.myget.org/F/nuget-volatile/api/v3/index.json", "NuGetVolatile");
var source2 = new Configuration.PackageSource("https://api.nuget.org/v3/index.json", "NuGet.org");
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { source1, source2 });
var repositories = sourceRepositoryProvider.GetRepositories();
var context = new PackageLoadContext(repositories, false, uiContext);
var packageFeed = new MultiSourcePackageFeed(repositories, logger: null);
var loader = new PackageItemLoader(context, packageFeed, "nuget");
var totalCount = await loader.GetTotalCountAsync(100, CancellationToken.None);
Assert.NotInRange(totalCount, 0, 99);
}
public async Task MultipleSources_Works()
{
var solutionManager = Mock.Of <IVsSolutionManager>();
var uiContext = Mock.Of <INuGetUIContext>();
Mock.Get(uiContext)
.Setup(x => x.SolutionManager)
.Returns(solutionManager);
var source1 = new Configuration.PackageSource("https://dotnet.myget.org/F/nuget-volatile/api/v3/index.json", "NuGetVolatile");
var source2 = new Configuration.PackageSource("https://api.nuget.org/v3/index.json", "NuGet.org");
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { source1, source2 });
var repositories = sourceRepositoryProvider.GetRepositories();
var context = new PackageLoadContext(repositories, false, uiContext);
var packageFeed = new MultiSourcePackageFeed(repositories, logger: null);
var loader = new PackageItemLoader(context, packageFeed, "nuget");
var loaded = new List <PackageItemListViewModel>();
foreach (var page in Enumerable.Range(0, 5))
{
await loader.LoadNextAsync(null, CancellationToken.None);
while (loader.State.LoadingStatus == LoadingStatus.Loading)
{
await Task.Delay(TimeSpan.FromSeconds(1));
await loader.UpdateStateAsync(null, CancellationToken.None);
}
var items = loader.GetCurrent();
loaded.AddRange(items);
if (loader.State.LoadingStatus != LoadingStatus.Ready)
{
break;
}
}
Assert.NotEmpty(loaded);
}
public async Task GetDownloadResourceResultAsync_MultipleSources_PackageDownloadedWhenFoundInMultipleSources()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[]
{
TestSourceRepositoryUtility.V3PackageSource,
TestSourceRepositoryUtility.V3PackageSource,
new PackageSource("http://unit.test"),
TestSourceRepositoryUtility.V2PackageSource,
TestSourceRepositoryUtility.V2PackageSource,
});
var packageIdentity = new PackageIdentity("jQuery", new NuGetVersion("1.8.2"));
// Act
using (var cacheContext = new SourceCacheContext())
{
var downloadContext = new PackageDownloadContext(cacheContext)
{
ExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
PackageExtractionBehavior.XmlDocFileSaveMode,
NullLogger.Instance,
signedPackageVerifier: null,
signedPackageVerifierSettings: null)
};
using (var packagesDirectory = TestDirectory.Create())
using (var downloadResult = await PackageDownloader.GetDownloadResourceResultAsync(
sourceRepositoryProvider.GetRepositories(),
packageIdentity,
downloadContext,
packagesDirectory,
NullLogger.Instance,
CancellationToken.None))
{
var targetPackageStream = downloadResult.PackageStream;
// Assert
Assert.True(targetPackageStream.CanSeek);
}
}
}
public async Task PackageReader_NotNull()
{
// Prepare
var solutionManager = Mock.Of <INuGetSolutionManagerService>();
var uiContext = new Mock <INuGetUIContext>();
uiContext.Setup(x => x.SolutionManagerService)
.Returns(solutionManager);
uiContext.Setup(x => x.ServiceBroker)
.Returns(Mock.Of <IServiceBroker>());
using (var localFeedDir = TestDirectory.Create()) // local feed
{
// create test package
var pkgId = new PackageIdentity("nuget.lpsm.test", new NuGetVersion(0, 0, 1));
var pkg = new SimpleTestPackageContext(pkgId.Id, pkgId.Version.ToNormalizedString());
await SimpleTestPackageUtility.CreatePackagesAsync(localFeedDir.Path, pkg);
// local test source
var localUri = new Uri(localFeedDir.Path, UriKind.Absolute);
var localSource = new PackageSource(localUri.ToString(), "LocalSource");
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { localSource });
var repositories = sourceRepositoryProvider.GetRepositories();
var context = new PackageLoadContext(repositories, isSolution: false, uiContext.Object);
var packageFeed = new MultiSourcePackageFeed(repositories, logger: null, telemetryService: null);
var loader = new PackageItemLoader(context, packageFeed, "nuget");
// Act
await loader.LoadNextAsync(progress : null, CancellationToken.None);
var results = loader.GetCurrent();
// Assert
Assert.Single(results);
Assert.NotNull(results.First().PackageReader);
}
}
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 GetDownloadResourceResultAsync_MultipleSources_DownloadsPackage()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[]
{
new PackageSource("https://www.myget.org/F/aspnetvnext/api/v2/"),
TestSourceRepositoryUtility.V3PackageSource,
new PackageSource("http://unit.test"),
});
var packageIdentity = new PackageIdentity("jQuery", new NuGetVersion("1.8.2"));
// Act
using (var cacheContext = new SourceCacheContext())
{
var downloadContext = new PackageDownloadContext(cacheContext)
{
ExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
PackageExtractionBehavior.XmlDocFileSaveMode,
clientPolicyContext: null,
logger: NullLogger.Instance)
};
using (var packagesDirectory = TestDirectory.Create())
using (var downloadResult = await PackageDownloader.GetDownloadResourceResultAsync(
sourceRepositoryProvider.GetRepositories(),
packageIdentity,
downloadContext,
packagesDirectory,
NullLogger.Instance,
CancellationToken.None))
{
var targetPackageStream = downloadResult.PackageStream;
// Assert
Assert.True(targetPackageStream.CanSeek);
}
}
}
public SharedServiceStateTests(GlobalServiceProvider globalServiceProvider)
: base(globalServiceProvider)
{
var solutionManager = new Mock <IVsSolutionManager>();
solutionManager.SetupGet(x => x.SolutionDirectory)
.Returns(@"C:\a");
SourceRepositoryProvider sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var componentModel = new Mock <IComponentModel>();
componentModel.Setup(x => x.GetService <IDeleteOnRestartManager>()).Returns(Mock.Of <IDeleteOnRestartManager>());
componentModel.Setup(x => x.GetService <ISettings>()).Returns(Mock.Of <ISettings>());
componentModel.Setup(x => x.GetService <ISourceRepositoryProvider>()).Returns(sourceRepositoryProvider);
componentModel.Setup(x => x.GetService <IVsSolutionManager>()).Returns(solutionManager.Object);
globalServiceProvider.AddService(typeof(SComponentModel), componentModel.Object);
var service = Package.GetGlobalService(typeof(SAsyncServiceProvider)) as IAsyncServiceProvider;
ServiceLocator.InitializePackageServiceProvider(service);
}
public async Task TestDownloadPackage_InV2()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV2OnlySourceRepositoryProvider();
var v2sourceRepository = sourceRepositoryProvider.GetRepositories().First();
var packageIdentity = new PackageIdentity("jQuery", new NuGetVersion("1.8.2"));
// Act
using (var downloadResult = await PackageDownloader.GetDownloadResourceResultAsync(v2sourceRepository,
packageIdentity,
Configuration.NullSettings.Instance,
Common.NullLogger.Instance,
CancellationToken.None))
{
var targetPackageStream = downloadResult.PackageStream;
// Assert
// jQuery.1.8.2 is of size 185476 bytes. Make sure the download is successful
Assert.Equal(185476, targetPackageStream.Length);
Assert.True(targetPackageStream.CanSeek);
}
}
private void Initialize(IReadOnlyList <PackageSource> packageSources = null)
{
SourceRepositoryProvider sourceRepositoryProvider;
if (packageSources == null || packageSources.Count == 0)
{
sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
}
else
{
sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(packageSources);
}
_solutionManager = new TestVsSolutionManager();
_testDirectory = TestDirectory.Create();
ISettings testSettings = CreateSettings(sourceRepositoryProvider, _testDirectory);
var deleteOnRestartManager = new TestDeleteOnRestartManager();
_packageManager = new NuGetPackageManager(
sourceRepositoryProvider,
testSettings,
_solutionManager,
deleteOnRestartManager);
_state = new NuGetProjectManagerServiceState();
_sharedState = new TestSharedServiceState(
new Microsoft.VisualStudio.Threading.AsyncLazy <NuGetPackageManager>(
() => Task.FromResult(_packageManager)),
new Microsoft.VisualStudio.Threading.AsyncLazy <IVsSolutionManager>(
() => Task.FromResult <IVsSolutionManager>(_solutionManager)),
sourceRepositoryProvider,
new Microsoft.VisualStudio.Threading.AsyncLazy <IReadOnlyCollection <SourceRepository> >(
() => Task.FromResult <IReadOnlyCollection <SourceRepository> >(sourceRepositoryProvider.GetRepositories().ToList())));
_projectManager = new NuGetProjectManagerService(
default(ServiceActivationOptions),
Mock.Of <IServiceBroker>(),
new AuthorizationServiceClient(Mock.Of <IAuthorizationService>()),
_state,
_sharedState);
}
public async Task GetDownloadResourceResultAsync_V3_DownloadsPackage()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var v3sourceRepository = sourceRepositoryProvider.GetRepositories().First();
var packageIdentity = new PackageIdentity("jQuery", new NuGetVersion("1.8.2"));
// Act
using (var cacheContext = new SourceCacheContext())
{
var downloadContext = new PackageDownloadContext(cacheContext)
{
ExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
PackageExtractionBehavior.XmlDocFileSaveMode,
NullLogger.Instance,
signedPackageVerifier: null,
signedPackageVerifierSettings: null)
};
using (var packagesDirectory = TestDirectory.Create())
using (var downloadResult = await PackageDownloader.GetDownloadResourceResultAsync(
v3sourceRepository,
packageIdentity,
downloadContext,
packagesDirectory,
NullLogger.Instance,
CancellationToken.None))
{
var targetPackageStream = downloadResult.PackageStream;
// Assert
// jQuery.1.8.2 is of size 185476 bytes. Make sure the download is successful
Assert.Equal(185476, targetPackageStream.Length);
Assert.True(targetPackageStream.CanSeek);
}
}
}
public async Task GetTotalCountAsync_Works()
{
var solutionManager = Mock.Of <INuGetSolutionManagerService>();
var uiContext = Mock.Of <INuGetUIContext>();
Mock.Get(uiContext)
.Setup(x => x.SolutionManagerService)
.Returns(solutionManager);
var source1 = new PackageSource("https://pkgs.dev.azure.com/dnceng/public/_packaging/nuget-build/nuget/v3/index.json", "NuGetBuild");
var source2 = new PackageSource("https://api.nuget.org/v3/index.json", "NuGet.org");
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { source1, source2 });
var repositories = sourceRepositoryProvider.GetRepositories();
var context = new PackageLoadContext(repositories, false, uiContext);
var packageFeed = new MultiSourcePackageFeed(repositories, logger: null, telemetryService: null);
var loader = new PackageItemLoader(context, packageFeed, "nuget");
var totalCount = await loader.GetTotalCountAsync(100, CancellationToken.None);
Assert.NotInRange(totalCount, 0, 99);
}
public async Task GetDownloadResourceResultAsync_MultipleSources_PackageNotFound()
{
// Arrange
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[]
{
new PackageSource("https://www.myget.org/F/aspnetvnext/api/v2/"),
new PackageSource("http://unit.test"),
});
var packageIdentity = new PackageIdentity("jQuery", new NuGetVersion("1.8.2"));
using (var packagesDirectory = TestDirectory.Create())
using (var cacheContext = new SourceCacheContext())
{
await Assert.ThrowsAsync <FatalProtocolException>(
async() => await PackageDownloader.GetDownloadResourceResultAsync(
sourceRepositoryProvider.GetRepositories(),
packageIdentity,
new PackageDownloadContext(cacheContext),
packagesDirectory,
NullLogger.Instance,
CancellationToken.None));
}
}
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 PackageReader_NotNull()
{
// Prepare
var solutionManager = Mock.Of <INuGetSolutionManagerService>();
var uiContext = new Mock <INuGetUIContext>();
uiContext.Setup(x => x.SolutionManagerService)
.Returns(solutionManager);
var searchService = new Mock <INuGetSearchService>(MockBehavior.Strict);
var packageSearchMetadata = new PackageSearchMetadataBuilder.ClonedPackageSearchMetadata()
{
Identity = new PackageIdentity("NuGet.org", new NuGetVersion("1.0")),
PrefixReserved = true
};
var packageSearchMetadataContextInfo = new List <PackageSearchMetadataContextInfo>()
{
PackageSearchMetadataContextInfo.Create(packageSearchMetadata)
};
var searchResult = new SearchResultContextInfo(packageSearchMetadataContextInfo, new Dictionary <string, LoadingStatus> {
{ "Search", LoadingStatus.Loading }
}, false);
searchService.Setup(x =>
x.SearchAsync(
It.IsAny <IReadOnlyCollection <IProjectContextInfo> >(),
It.IsAny <IReadOnlyCollection <PackageSourceContextInfo> >(),
It.IsAny <IReadOnlyCollection <string> >(),
It.IsAny <string>(),
It.IsAny <SearchFilter>(),
It.IsAny <NuGet.VisualStudio.Internal.Contracts.ItemFilter>(),
It.IsAny <bool>(),
It.IsAny <CancellationToken>()))
.Returns(new ValueTask <SearchResultContextInfo>(searchResult));
uiContext.Setup(x => x.ServiceBroker)
.Returns(Mock.Of <IServiceBroker>());
using (var localFeedDir = TestDirectory.Create()) // local feed
{
// create test package
var pkgId = new PackageIdentity("nuget.lpsm.test", new NuGetVersion(0, 0, 1));
var pkg = new SimpleTestPackageContext(pkgId.Id, pkgId.Version.ToNormalizedString());
await SimpleTestPackageUtility.CreatePackagesAsync(localFeedDir.Path, pkg);
// local test source
var localUri = new Uri(localFeedDir.Path, UriKind.Absolute);
var localSource = new PackageSource(localUri.ToString(), "LocalSource");
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { localSource });
var repositories = sourceRepositoryProvider.GetRepositories();
var context = new PackageLoadContext(isSolution: false, uiContext.Object);
var packageFeed = new MultiSourcePackageFeed(repositories, logger: null, telemetryService: null);
var loader = await PackageItemLoader.CreateAsync(
Mock.Of <IServiceBroker>(),
context,
new List <PackageSourceContextInfo> {
PackageSourceContextInfo.Create(localSource)
},
NuGet.VisualStudio.Internal.Contracts.ItemFilter.All,
searchService.Object,
TestSearchTerm);
// Act
await loader.LoadNextAsync(progress : null, CancellationToken.None);
var results = loader.GetCurrent();
// Assert
Assert.Single(results);
Assert.NotNull(results.First().PackageReader);
}
}
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));
}
}
public async Task EmitsSearchTelemetryEvents()
{
// Arrange
var solutionManager = Mock.Of <IVsSolutionManager>();
var uiContext = Mock.Of <INuGetUIContext>();
Mock.Get(uiContext)
.Setup(x => x.SolutionManager)
.Returns(solutionManager);
var telemetryService = new Mock <INuGetTelemetryService>();
var eventsQueue = new ConcurrentQueue <TelemetryEvent>();
telemetryService
.Setup(x => x.EmitTelemetryEvent(It.IsAny <TelemetryEvent>()))
.Callback <TelemetryEvent>(e => eventsQueue.Enqueue(e));
// Mock all the remote calls our test will try to make.
var source = NuGetConstants.V3FeedUrl;
var query = "https://api-v2v3search-0.nuget.org/query";
var responses = new Dictionary <string, string>
{
{
source,
ProtocolUtility.GetResource("NuGet.PackageManagement.UI.Test.compiler.resources.index.json", typeof(PackageItemLoaderTests))
},
{
query + "?q=nuget&skip=0&take=26&prerelease=true&semVerLevel=2.0.0",
ProtocolUtility.GetResource("NuGet.PackageManagement.UI.Test.compiler.resources.nugetSearchPage1.json", typeof(PackageItemLoaderTests))
},
{
query + "?q=nuget&skip=25&take=26&prerelease=true&semVerLevel=2.0.0",
ProtocolUtility.GetResource("NuGet.PackageManagement.UI.Test.compiler.resources.nugetSearchPage2.json", typeof(PackageItemLoaderTests))
},
};
using (var httpSource = new TestHttpSource(new PackageSource(source), responses))
{
var injectedHttpSources = new Dictionary <string, HttpSource>();
injectedHttpSources.Add(source, httpSource);
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { new PackageSource(source) }, new Lazy <INuGetResourceProvider>[] { new Lazy <INuGetResourceProvider>(() => new TestHttpSourceResourceProvider(injectedHttpSources)) });
var repositories = sourceRepositoryProvider.GetRepositories();
var context = new PackageLoadContext(repositories, false, uiContext);
var packageFeed = new MultiSourcePackageFeed(repositories, logger: null, telemetryService: telemetryService.Object);
// Act
var loader = new PackageItemLoader(context, packageFeed, searchText: "nuget", includePrerelease: true);
await loader.LoadNextAsync(null, CancellationToken.None);
await loader.LoadNextAsync(null, CancellationToken.None);
// Assert
var events = eventsQueue.ToArray();
Assert.True(4 == events.Length, string.Join(Environment.NewLine, events.Select(e => e.Name)));
var search = Assert.Single(events, e => e.Name == "Search");
Assert.Equal(true, search["IncludePrerelease"]);
Assert.Equal("nuget", search.GetPiiData().First(p => p.Key == "Query").Value);
var operationId = Assert.IsType <string>(search["OperationId"]);
var parsedOperationId = Guid.ParseExact(operationId, "D");
var sources = Assert.Single(events, e => e.Name == "SearchPackageSourceSummary");
Assert.Equal(1, sources["NumHTTPv3Feeds"]);
Assert.Equal("YesV3", sources["NuGetOrg"]);
Assert.Equal(operationId, sources["ParentId"]);
var page0 = Assert.Single(events, e => e.Name == "SearchPage" && e["PageIndex"] is int && (int)e["PageIndex"] == 0);
Assert.Equal("Ready", page0["LoadingStatus"]);
Assert.Equal(operationId, page0["ParentId"]);
Assert.IsType <int>(page0["ResultCount"]);
Assert.IsType <double>(page0["Duration"]);
Assert.IsType <double>(page0["ResultsAggregationDuration"]);
Assert.IsType <string>(page0["IndividualSourceDurations"]);
Assert.Equal(1, ((JArray)JsonConvert.DeserializeObject((string)page0["IndividualSourceDurations"])).Values <double>().Count());
var page1 = Assert.Single(events, e => e.Name == "SearchPage" && e["PageIndex"] is int && (int)e["PageIndex"] == 1);
Assert.Equal("Ready", page1["LoadingStatus"]);
Assert.Equal(operationId, page1["ParentId"]);
Assert.IsType <int>(page1["ResultCount"]);
Assert.IsType <double>(page1["Duration"]);
Assert.IsType <double>(page1["ResultsAggregationDuration"]);
Assert.IsType <string>(page1["IndividualSourceDurations"]);
Assert.Equal(1, ((JArray)JsonConvert.DeserializeObject((string)page1["IndividualSourceDurations"])).Values <double>().Count());
Assert.Equal(parsedOperationId, loader.State.OperationId);
}
}
public async Task EmitsSearchTelemetryEvents()
{
// Arrange
var solutionManager = Mock.Of <IVsSolutionManager>();
var uiContext = Mock.Of <INuGetUIContext>();
Mock.Get(uiContext)
.Setup(x => x.SolutionManager)
.Returns(solutionManager);
var telemetryService = new Mock <INuGetTelemetryService>();
var eventsQueue = new ConcurrentQueue <TelemetryEvent>();
telemetryService
.Setup(x => x.EmitTelemetryEvent(It.IsAny <TelemetryEvent>()))
.Callback <TelemetryEvent>(e => eventsQueue.Enqueue(e));
var source = new Configuration.PackageSource("https://api.nuget.org/v3/index.json", "NuGet.org");
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { source });
var repositories = sourceRepositoryProvider.GetRepositories();
var context = new PackageLoadContext(repositories, false, uiContext);
var packageFeed = new MultiSourcePackageFeed(repositories, logger: null, telemetryService: telemetryService.Object);
// Act
var loader = new PackageItemLoader(context, packageFeed, searchText: "nuget", includePrerelease: true);
await loader.LoadNextAsync(null, CancellationToken.None);
await loader.LoadNextAsync(null, CancellationToken.None);
// Assert
var events = eventsQueue.ToArray();
Assert.Equal(4, events.Length);
var search = events[0];
Assert.Equal("Search", search.Name);
Assert.Equal(true, search["IncludePrerelease"]);
Assert.Equal("nuget", search.GetPiiData().First(p => p.Key == "Query").Value);
var operationId = Assert.IsType <string>(search["OperationId"]);
var parsedOperationId = Guid.ParseExact(operationId, "D");
var sources = events[1];
Assert.Equal("SearchPackageSourceSummary", sources.Name);
Assert.Equal(1, sources["NumHTTPv3Feeds"]);
Assert.Equal("YesV3", sources["NuGetOrg"]);
Assert.Equal(operationId, sources["ParentId"]);
var page0 = events[2];
Assert.Equal("SearchPage", page0.Name);
Assert.Equal("Ready", page0["LoadingStatus"]);
Assert.Equal(0, page0["PageIndex"]);
Assert.Equal(operationId, page0["ParentId"]);
Assert.IsType <int>(page0["ResultCount"]);
Assert.IsType <double>(page0["Duration"]);
Assert.IsType <double>(page0["ResultsAggregationDuration"]);
Assert.IsType <string>(page0["IndividualSourceDurations"]);
Assert.Equal(1, ((JArray)JsonConvert.DeserializeObject((string)page0["IndividualSourceDurations"])).Values <double>().Count());
var page1 = events[3];
Assert.Equal("SearchPage", page1.Name);
Assert.Equal("Ready", page1["LoadingStatus"]);
Assert.Equal(1, page1["PageIndex"]);
Assert.Equal(operationId, page1["ParentId"]);
Assert.IsType <int>(page1["ResultCount"]);
Assert.IsType <double>(page1["Duration"]);
Assert.IsType <double>(page1["ResultsAggregationDuration"]);
Assert.IsType <string>(page1["IndividualSourceDurations"]);
Assert.Equal(1, ((JArray)JsonConvert.DeserializeObject((string)page1["IndividualSourceDurations"])).Values <double>().Count());
Assert.Equal(parsedOperationId, loader.State.OperationId);
}
public async Task GetTotalCountAsync_WithGreaterThanOrEqualToMaxCountResults_ReturnsMaxCount()
{
var source1 = new PackageSource("https://dotnet.myget.org/F/nuget-volatile/api/v3/index.json", "NuGetVolatile");
var source2 = new PackageSource("https://api.nuget.org/v3/index.json", "NuGet.org");
var sources = new List <PackageSource> {
source1, source2
};
var sourceRepository = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(new[] { source1, source2 });
var solutionManager = new Mock <IVsSolutionManager>();
solutionManager.SetupGet(x => x.SolutionDirectory).Returns("z:\\SomeRandomPath");
var settings = new Mock <ISettings>();
var deleteOnRestartManager = new Mock <IDeleteOnRestartManager>();
AddService <IDeleteOnRestartManager>(Task.FromResult <object>(deleteOnRestartManager.Object));
AddService <IVsSolutionManager>(Task.FromResult <object>(solutionManager.Object));
AddService <ISettings>(Task.FromResult <object>(settings.Object));
AddService <ISourceRepositoryProvider>(Task.FromResult <object>(sourceRepository));
var serviceActivationOptions = default(ServiceActivationOptions);
var serviceBroker = new Mock <IServiceBroker>();
var authorizationService = new AuthorizationServiceClient(Mock.Of <IAuthorizationService>());
var sharedState = new SharedServiceState(sourceRepository);
var projectManagerService = new Mock <INuGetProjectManagerService>();
var installedPackages = new List <IPackageReferenceContextInfo>();
var projects = new List <IProjectContextInfo>
{
new ProjectContextInfo(
Guid.NewGuid().ToString(),
ProjectModel.ProjectStyle.PackageReference,
NuGetProjectKind.PackageReference)
};
projectManagerService.Setup(x => x.GetInstalledPackagesAsync(
It.IsAny <IReadOnlyCollection <string> >(),
It.IsAny <CancellationToken>()))
.Returns(new ValueTask <IReadOnlyCollection <IPackageReferenceContextInfo> >(installedPackages));
#pragma warning disable ISB001 // Dispose of proxies
serviceBroker.Setup(x => x.GetProxyAsync <INuGetProjectManagerService>(
NuGetServices.ProjectManagerService,
It.IsAny <ServiceActivationOptions>(),
It.IsAny <CancellationToken>()))
.Returns(new ValueTask <INuGetProjectManagerService>(projectManagerService.Object));
#pragma warning restore ISB001 // Dispose of proxies
using (var searchService = new NuGetPackageSearchService(
serviceActivationOptions,
serviceBroker.Object,
authorizationService,
sharedState))
{
const int MaxCount = 100;
int totalCount = await searchService.GetTotalCountAsync(
MaxCount,
projects,
sources.Select(s => PackageSourceContextInfo.Create(s)).ToList(),
targetFrameworks : new List <string>()
{
"net45", "net5.0"
},
new SearchFilter(includePrerelease : true),
NuGet.VisualStudio.Internal.Contracts.ItemFilter.All,
CancellationToken.None);
Assert.Equal(MaxCount, totalCount);
}
}
public async Task EnumeratePackagesAsync_ForPackagesConfig_ReturnsOrderedItems()
{
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
using (var testDirectory = TestDirectory.Create())
{
var testSettings = PopulateSettingsWithSources(sourceRepositoryProvider, testDirectory);
var solutionDirectory = Path.Combine(testDirectory.Path, "solutionA");
Directory.CreateDirectory(solutionDirectory);
var testSolutionManager = new TestSolutionManager(solutionDirectory);
var userPackageFolder = Path.Combine(testDirectory.Path, "packagesA");
Directory.CreateDirectory(userPackageFolder);
testSettings.SetValue("config", "repositoryPath", userPackageFolder);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(
solutionDirectory, testSettings);
var packageBar = new SimpleTestPackageContext
{
Id = "Bar",
Version = "1.0.2"
};
var packageFoo = new SimpleTestPackageContext
{
Id = "Foo",
Version = "1.0.1",
Dependencies = new List <SimpleTestPackageContext> {
packageBar
}
};
await SimpleTestPackageUtility.CreateFolderFeedPackagesConfigAsync(
packagesFolderPath,
packageFoo,
packageBar);
var target = new InstalledPackageEnumerator(
testSolutionManager,
testSettings,
getLockFileOrNullAsync: _ => Task.FromResult <LockFile>(null));
var projectSystem = Mock.Of <IMSBuildProjectSystem>();
Mock.Get(projectSystem)
.SetupGet(x => x.TargetFramework)
.Returns(NuGetFramework.Parse("net45"));
var project = new Mock <MSBuildNuGetProject>(
projectSystem, packagesFolderPath, testDirectory.Path);
project
.Setup(x => x.GetInstalledPackagesAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(new[]
{
new PackageReference(
new PackageIdentity("Foo", NuGetVersion.Parse("1.0.1")),
NuGetFramework.Parse("net45")),
new PackageReference(
new PackageIdentity("Bar", NuGetVersion.Parse("1.0.2")),
NuGetFramework.Parse("net45"))
})
.Verifiable();
testSolutionManager.NuGetProjects.Add(project.Object);
var testPackageManager = new NuGetPackageManager(
sourceRepositoryProvider,
testSettings,
packagesFolderPath);
// Act
var installedPackages = await target.EnumeratePackagesAsync(
testPackageManager,
CancellationToken.None);
// Assert: Order is important!
installedPackages.Should().Equal(
new PackageItem(
new PackageIdentity("Bar", NuGetVersion.Parse("1.0.2")),
Path.Combine(packagesFolderPath, "Bar.1.0.2")),
new PackageItem(
new PackageIdentity("Foo", NuGetVersion.Parse("1.0.1")),
Path.Combine(packagesFolderPath, "Foo.1.0.1")));
project.Verify();
}
}
public async Task EnumeratePackagesAsync_ForBuildIntegratedProject_ReturnsOrderedItems()
{
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
using (var testDirectory = TestDirectory.Create())
{
var testSettings = PopulateSettingsWithSources(sourceRepositoryProvider, testDirectory);
var solutionDirectory = Path.Combine(testDirectory.Path, "solutionA");
Directory.CreateDirectory(solutionDirectory);
var testSolutionManager = new TestSolutionManager(solutionDirectory);
testSolutionManager.NuGetProjects.Add(Mock.Of <BuildIntegratedNuGetProject>());
var userPackageFolder = Path.Combine(testDirectory.Path, "userPackages");
Directory.CreateDirectory(userPackageFolder);
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
userPackageFolder,
new PackageIdentity("Foo", NuGetVersion.Parse("1.0.1")));
var fallbackPackageFolder = Path.Combine(testDirectory.Path, "fallbackPackages");
Directory.CreateDirectory(fallbackPackageFolder);
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
fallbackPackageFolder,
new PackageIdentity("Bar", NuGetVersion.Parse("1.0.2")));
var target = new InstalledPackageEnumerator(
testSolutionManager,
testSettings,
getLockFileOrNullAsync: _ => Task.FromResult(
new LockFile
{
PackageFolders = new[]
{
new LockFileItem(userPackageFolder),
new LockFileItem(fallbackPackageFolder)
},
Targets = new[]
{
new LockFileTarget
{
TargetFramework = NuGetFramework.Parse("netcoreapp2.0"),
Libraries = new[]
{
new LockFileTargetLibrary
{
Type = LibraryType.Package,
Name = "Foo",
Version = NuGetVersion.Parse("1.0.1"),
Dependencies = new[]
{
new PackageDependency("Bar")
}
},
new LockFileTargetLibrary
{
Type = LibraryType.Package,
Name = "Bar",
Version = NuGetVersion.Parse("1.0.2")
}
}
}
},
Libraries = new[]
{
new LockFileLibrary
{
Type = LibraryType.Package,
Name = "Foo",
Version = NuGetVersion.Parse("1.0.1")
},
new LockFileLibrary
{
Type = LibraryType.Package,
Name = "Bar",
Version = NuGetVersion.Parse("1.0.2")
}
}
}));
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(
solutionDirectory, testSettings);
var testPackageManager = new NuGetPackageManager(
sourceRepositoryProvider,
testSettings,
packagesFolderPath);
// Act
var installedPackages = await target.EnumeratePackagesAsync(
testPackageManager,
CancellationToken.None);
// Assert: Order is important!
installedPackages.Should().Equal(
new PackageItem(
new PackageIdentity("Bar", NuGetVersion.Parse("1.0.2")),
Path.Combine(fallbackPackageFolder, "bar", "1.0.2")),
new PackageItem(
new PackageIdentity("Foo", NuGetVersion.Parse("1.0.1")),
Path.Combine(userPackageFolder, "foo", "1.0.1")));
}
}
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_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 Task BuildIntegratedRestoreUtility_RestoreDeferredProjectLoad()
{
// Arrange
var projectName = "testproj";
var project1Json = @"
{
""version"": ""1.0.0"",
""description"": """",
""authors"": [ ""author"" ],
""tags"": [ """" ],
""projectUrl"": """",
""licenseUrl"": """",
""frameworks"": {
""net45"": {
""dependencies"": {
""packageA"": ""1.0.0""
}
}
}
}";
using (var packageSource = TestDirectory.Create())
using (var rootFolder = TestDirectory.Create())
{
var sourceRepositoryProvider = TestSourceRepositoryUtility.CreateSourceRepositoryProvider(
new List <PackageSource>()
{
new PackageSource(packageSource.Path)
});
var packageContext = new SimpleTestPackageContext("packageA");
packageContext.AddFile("lib/net45/a.dll");
SimpleTestPackageUtility.CreateOPCPackage(packageContext, packageSource);
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var projectConfig = Path.Combine(projectFolder.FullName, "project.json");
var projectPath = Path.Combine(projectFolder.FullName, $"{projectName}.csproj");
var packageSpec = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", projectConfig);
var metadata = new ProjectRestoreMetadata();
packageSpec.RestoreMetadata = metadata;
metadata.ProjectStyle = ProjectStyle.ProjectJson;
metadata.ProjectPath = projectPath;
metadata.ProjectJsonPath = packageSpec.FilePath;
metadata.ProjectName = packageSpec.Name;
metadata.ProjectUniqueName = projectPath;
foreach (var framework in packageSpec.TargetFrameworks.Select(e => e.FrameworkName))
{
metadata.TargetFrameworks.Add(new ProjectRestoreMetadataFrameworkInfo(framework));
}
var solutionManager = new TestSolutionManager(false);
var testLogger = new TestLogger();
var restoreContext = new DependencyGraphCacheContext(testLogger);
restoreContext.DeferredPackageSpecs.Add(packageSpec);
// Act
await DependencyGraphRestoreUtility.RestoreAsync(
solutionManager,
restoreContext,
new RestoreCommandProvidersCache(),
(c) => { },
sourceRepositoryProvider.GetRepositories(),
NullSettings.Instance,
testLogger,
CancellationToken.None);
// Assert
Assert.True(File.Exists(Path.Combine(projectFolder.FullName, "project.lock.json")));
Assert.True(testLogger.Errors == 0);
}
}
