public async Task CreatePathContextAsync_WithUnrestoredPackageReference_Throws()
        {
            var target = new VsPathContextProvider(
                Mock.Of <ISettings>(),
                Mock.Of <IVsSolutionManager>(),
                Mock.Of <ILogger>(),
                getLockFileOrNullAsync: _ => Task.FromResult(null as LockFile));

            var projectUniqueName = Guid.NewGuid().ToString();

            var project = new TestPackageReferenceProject(projectUniqueName);

            // Act
            var exception = await Assert.ThrowsAsync <InvalidOperationException>(() => target.CreatePathContextAsync(project, CancellationToken.None));

            Assert.Contains(projectUniqueName, exception.Message);
        }
        public async Task CreatePathContextAsync_CancellationToken_ThrowsAsync()
        {
            // Prepare
            var target = new VsPathContextProvider(
                Mock.Of <ISettings>(),
                Mock.Of <IVsSolutionManager>(),
                Mock.Of <ILogger>(),
                getLockFileOrNullAsync: _ => Task.FromResult(null as LockFile),
                _telemetryProvider.Object);
            var project = new TestPackageReferenceProject(Guid.NewGuid().ToString()); // non-packages.config project
            var cts     = new CancellationTokenSource();

            cts.Cancel();
            var task = target.CreatePathContextAsync(project, cts.Token);

            // Act and Assert
            await Assert.ThrowsAsync <OperationCanceledException>(async() => await task);
        }
        public async Task GetInstalledPackagesAsync_PackageReferenceProject_ReturnsTransitiveAsync()
        {
            // Arrange
            var projectGuid = Guid.NewGuid();

            var settings          = new Mock <ISettings>();
            var telemetryProvider = new Mock <INuGetTelemetryProvider>(MockBehavior.Strict);

            var installedPackages = new List <PackageReference>()
            {
                new PackageReference(new PackageIdentity("a", new NuGetVersion(1, 0, 0)), FrameworkConstants.CommonFrameworks.Net50)
            };
            var transitivePackages = new List <PackageReference>()
            {
                new PackageReference(new PackageIdentity("b", new NuGetVersion(1, 2, 3)), FrameworkConstants.CommonFrameworks.Net50)
            };
            var transitiveProjectPackages = transitivePackages.Select(p => new TransitivePackageReference(p)).ToList();
            var projectPackages           = new ProjectPackages(installedPackages, transitiveProjectPackages);
            var project = new TestPackageReferenceProject("ProjectA", @"src\ProjectA\Project.csproj", @"c:\path\to\src\ProjectA\ProjectA.csproj",
                                                          installedPackages, transitivePackages);

            var solutionManager = new Mock <IVsSolutionManager>();

            solutionManager.Setup(sm => sm.GetNuGetProjectAsync(projectGuid.ToString()))
            .Returns(() => Task.FromResult <NuGetProject>(project));

            // Act
            var target = new NuGetProjectService(solutionManager.Object, settings.Object, telemetryProvider.Object);
            InstalledPackagesResult actual = await target.GetInstalledPackagesAsync(projectGuid, CancellationToken.None);

            // Assert
            Assert.NotNull(actual);
            Assert.Equal(InstalledPackageResultStatus.Successful, actual.Status);

            NuGetInstalledPackage package = actual.Packages.FirstOrDefault(p => p.Id == "a");

            Assert.NotNull(package);
            Assert.True(package.DirectDependency);

            package = actual.Packages.FirstOrDefault(p => p.Id == "b");
            Assert.NotNull(package);
            Assert.False(package.DirectDependency);
        }