dependabot-nuget 0.287.0 → 0.288.0

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Utilities/MSBuildHelper.cs

@@ -1,5 +1,6 @@
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
 using System.Text;
 using System.Text.Json;
 using System.Text.Json.Nodes;
@@ -13,7 +14,6 @@ using Microsoft.Build.Exceptions;
 using Microsoft.Build.Locator;
 using Microsoft.Extensions.FileSystemGlobbing;
 
-using NuGet;
 using NuGet.Configuration;
 using NuGet.Frameworks;
 using NuGet.Versioning;
@@ -39,12 +39,12 @@ internal static partial class MSBuildHelper
                 var defaultInstance = MSBuildLocator.QueryVisualStudioInstances().First();
                 MSBuildPath = defaultInstance.MSBuildPath;
                 MSBuildLocator.RegisterInstance(defaultInstance);
-                return Task.CompletedTask;
+                return Task.FromResult(0);
             }).Wait();
         }
     }
 
-    public static async Task SidelineGlobalJsonAsync(string currentDirectory, string rootDirectory, Func<Task> action, ILogger? logger = null, bool retainMSBuildSdks = false)
+    public static async Task<T> SidelineGlobalJsonAsync<T>(string currentDirectory, string rootDirectory, Func<Task<T>> action, ILogger? logger = null, bool retainMSBuildSdks = false)
     {
         logger ??= new ConsoleLogger();
         var candidateDirectories = PathHelper.GetAllDirectoriesToRoot(currentDirectory, rootDirectory);
@@ -73,7 +73,8 @@ internal static partial class MSBuildHelper
 
         try
         {
-            await action();
+            var result = await action();
+            return result;
         }
         finally
         {
@@ -747,6 +748,58 @@ internal static partial class MSBuildHelper
         return tempProjectPath;
     }
 
+    internal static async Task<ImmutableArray<string>> GetTargetFrameworkValuesFromProject(string repoRoot, string projectPath, ILogger logger)
+    {
+        // TODO: once the updater image has all relevant SDKs installed, we won't have to sideline global.json anymore
+        var projectDirectory = Path.GetDirectoryName(projectPath)!;
+        var (exitCode, stdOut, stdErr) = await SidelineGlobalJsonAsync(projectDirectory, repoRoot, async () =>
+        {
+            var targetsHelperPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)!, "TargetFrameworkReporter.targets");
+            var (exitCode, stdOut, stdErr) = await ProcessEx.RunAsync("dotnet", ["build", projectPath, "/t:ReportTargetFramework", $"/p:CustomAfterMicrosoftCommonCrossTargetingTargets={targetsHelperPath};CustomAfterMicrosoftCommonTargets={targetsHelperPath}"], workingDirectory: Path.GetDirectoryName(projectPath));
+            return (exitCode, stdOut, stdErr);
+        });
+        ThrowOnUnauthenticatedFeed(stdOut);
+        if (exitCode != 0)
+        {
+            logger.Log($"Error determining target frameworks.\nSTDOUT:\n{stdOut}\nSTDERR:\n{stdErr}");
+        }
+
+        // There are 3 return values, all uses slightly differently.  Only one will be set, the others will be blank
+        //   ProjectData::TargetFrameworkVersion=.NETFramework,Version=v4.5     // non-SDK projects, commonly with `packages.config`
+        //   ProjectData::TargetFramework=net7.0                                // SDK-style projects
+        //   ProjectData::TargetFrameworks=net7.0;net8.0
+        var tfmPatterns = new Regex[]
+        {
+            new Regex("ProjectData::TargetFrameworkVersion=(?<Value>.*)$", RegexOptions.Multiline),
+            new Regex("ProjectData::TargetFramework=(?<Value>.*)$", RegexOptions.Multiline),
+            new Regex("ProjectData::TargetFrameworks=(?<Value>.*)$", RegexOptions.Multiline),
+        };
+        var tfms = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        foreach (var tfmPattern in tfmPatterns)
+        {
+            var candidateTfms = tfmPattern.Matches(stdOut)
+                .Select(m => m.Groups["Value"].Value)
+                .SelectMany(v => v.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
+                .Where(v => !string.IsNullOrWhiteSpace(v))
+                .Select(v =>
+                {
+                    try
+                    {
+                        var framework = NuGetFramework.Parse(v);
+                        return framework.GetShortFolderName();
+                    }
+                    catch
+                    {
+                        return string.Empty;
+                    }
+                })
+                .Where(tfm => !string.IsNullOrEmpty(tfm));
+            tfms.AddRange(candidateTfms);
+        }
+
+        return tfms.ToImmutableArray();
+    }
+
     internal static async Task<Dependency[]> GetAllPackageDependenciesAsync(
         string repoRoot,
         string projectPath,

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Utilities/PathComparer.cs

@@ -0,0 +1,31 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace NuGetUpdater.Core.Utilities;
+
+public class PathComparer : IEqualityComparer<string>
+{
+    public static PathComparer Instance { get; } = new PathComparer();
+
+    public bool Equals(string? x, string? y)
+    {
+        x = x?.NormalizePathToUnix();
+        y = y?.NormalizePathToUnix();
+
+        if (x is null && y is null)
+        {
+            return true;
+        }
+
+        if (x is null || y is null)
+        {
+            return false;
+        }
+
+        return x.Equals(y, StringComparison.OrdinalIgnoreCase);
+    }
+
+    public int GetHashCode([DisallowNull] string obj)
+    {
+        return obj.NormalizePathToUnix().GetHashCode();
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Utilities/PathHelper.cs

@@ -1,3 +1,6 @@
+using System.Runtime.InteropServices;
+using System.Text.RegularExpressions;
+
 namespace NuGetUpdater.Core;
 
 internal static class PathHelper
@@ -63,7 +66,17 @@ internal static class PathHelper
         return result;
     }
 
-    public static string FullyNormalizedRootedPath(this string path) => path.NormalizePathToUnix().NormalizeUnixPathParts().EnsurePrefix("/");
+    public static string FullyNormalizedRootedPath(this string path)
+    {
+        var normalizedPath = path.NormalizePathToUnix().NormalizeUnixPathParts();
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Regex.IsMatch(normalizedPath, @"^[a-z]:", RegexOptions.IgnoreCase))
+        {
+            // Windows path is ready to go
+            return normalizedPath;
+        }
+
+        return normalizedPath.EnsurePrefix("/");
+    }
 
     public static string GetFullPathFromRelative(string rootPath, string relativePath)
         => Path.GetFullPath(JoinPath(rootPath, relativePath.NormalizePathToUnix()));
@@ -133,7 +146,7 @@ internal static class PathHelper
             currentPath = nextPath;
         }
 
-        return currentPath; // Fully resolved path with correct casing
+        return currentPath.NormalizePathToUnix(); // Fully resolved path with correct casing
     }
 
     /// <summary>
@@ -212,4 +225,19 @@ internal static class PathHelper
 
         return false;
     }
+
+    public static bool IsFileUnderDirectory(DirectoryInfo directory, FileInfo candidateFile)
+    {
+        // n.b., using `DirectoryInfo` and `FileInfo` here to ensure that the callsite doesn't get confused with just strings
+        // the paths are then normalized to make the comparison easier.
+        var directoryPath = directory.FullName.NormalizePathToUnix();
+        if (!directoryPath.EndsWith("/"))
+        {
+            // ensuring a trailing slash means we can do a simple string check later on
+            directoryPath += "/";
+        }
+        var candidateFilePath = candidateFile.FullName.NormalizePathToUnix();
+
+        return candidateFilePath.StartsWith(directoryPath);
+    }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Analyze/AnalyzeWorkerTests.cs

@@ -347,6 +347,56 @@ public partial class AnalyzeWorkerTests : AnalyzeWorkerTestBase
         );
     }
 
+    [Fact]
+    public async Task DuplicateTargetFrameworksWithCasingDifferencesAreCombined()
+    {
+        await TestAnalyzeAsync(
+            packages:
+            [
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "1.0.0", "net8.0"),
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "1.1.0", "net8.0"),
+            ],
+            discovery: new()
+            {
+                Path = "",
+                Projects = [
+                    new()
+                    {
+                        FilePath = "projecta/projecta.csproj",
+                        TargetFrameworks = ["net8.0"],
+                        Dependencies = [
+                            new("Some.Package", "1.0.0", DependencyType.PackageReference, TargetFrameworks: ["net8.0"]),
+                        ]
+                    },
+                    new()
+                    {
+                        FilePath = "projectb/projectb.csproj",
+                        TargetFrameworks = ["NET8.0"],
+                        Dependencies = [
+                            new("Some.Package", "1.0.0", DependencyType.PackageReference, TargetFrameworks: ["net8.0"]),
+                        ]
+                    }
+                ]
+            },
+            dependencyInfo: new()
+            {
+                Name = "Some.Package",
+                Version = "1.0.0",
+                IsVulnerable = false,
+                IgnoredVersions = [],
+                Vulnerabilities = [],
+            },
+            expectedResult: new()
+            {
+                UpdatedVersion = "1.1.0",
+                CanUpdate = true,
+                UpdatedDependencies = [
+                    new("Some.Package", "1.1.0", DependencyType.Unknown, TargetFrameworks: ["net8.0"]),
+                ],
+            }
+        );
+    }
+
     [Fact]
     public async Task IgnoredVersionsCanHandleWildcardSpecification()
     {

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Discover/DiscoveryWorkerTestBase.cs

@@ -1,10 +1,12 @@
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
 using System.Text.Json;
 
 using NuGetUpdater.Core.Discover;
 using NuGetUpdater.Core.Test.Update;
 using NuGetUpdater.Core.Test.Utilities;
+using NuGetUpdater.Core.Utilities;
 
 using Xunit;
 
@@ -12,41 +14,43 @@ namespace NuGetUpdater.Core.Test.Discover;
 
 using TestFile = (string Path, string Content);
 
-public class DiscoveryWorkerTestBase
+public class DiscoveryWorkerTestBase : TestBase
 {
     protected static async Task TestDiscoveryAsync(
         string workspacePath,
         TestFile[] files,
         ExpectedWorkspaceDiscoveryResult expectedResult,
-        MockNuGetPackage[]? packages = null)
+        MockNuGetPackage[]? packages = null,
+        ExperimentsManager? experimentsManager = null)
     {
+        experimentsManager ??= new ExperimentsManager();
         var actualResult = await RunDiscoveryAsync(files, async directoryPath =>
         {
             await UpdateWorkerTestBase.MockNuGetPackagesInDirectory(packages, directoryPath);
 
-            var worker = new DiscoveryWorker(new TestLogger());
+            var worker = new DiscoveryWorker(experimentsManager, new TestLogger());
             var result = await worker.RunWithErrorHandlingAsync(directoryPath, workspacePath);
             return result;
         });
 
-        ValidateWorkspaceResult(expectedResult, actualResult);
+        ValidateWorkspaceResult(expectedResult, actualResult, experimentsManager);
     }
 
-    protected static void ValidateWorkspaceResult(ExpectedWorkspaceDiscoveryResult expectedResult, WorkspaceDiscoveryResult actualResult)
+    protected static void ValidateWorkspaceResult(ExpectedWorkspaceDiscoveryResult expectedResult, WorkspaceDiscoveryResult actualResult, ExperimentsManager experimentsManager)
     {
         Assert.NotNull(actualResult);
         Assert.Equal(expectedResult.Path.NormalizePathToUnix(), actualResult.Path.NormalizePathToUnix());
-        ValidateDirectoryPackagesProps(expectedResult.DirectoryPackagesProps, actualResult.DirectoryPackagesProps);
         ValidateResultWithDependencies(expectedResult.GlobalJson, actualResult.GlobalJson);
         ValidateResultWithDependencies(expectedResult.DotNetToolsJson, actualResult.DotNetToolsJson);
-        ValidateProjectResults(expectedResult.Projects, actualResult.Projects);
+        ValidateProjectResults(expectedResult.Projects, actualResult.Projects, experimentsManager);
+        AssertEx.Equal(expectedResult.ImportedFiles, actualResult.ImportedFiles, PathComparer.Instance);
         Assert.Equal(expectedResult.ExpectedProjectCount ?? expectedResult.Projects.Length, actualResult.Projects.Length);
         Assert.Equal(expectedResult.ErrorType, actualResult.ErrorType);
         Assert.Equal(expectedResult.ErrorDetails, actualResult.ErrorDetails);
 
         return;
 
-        void ValidateResultWithDependencies(ExpectedDependencyDiscoveryResult? expectedResult, IDiscoveryResultWithDependencies? actualResult)
+        static void ValidateResultWithDependencies(ExpectedDependencyDiscoveryResult? expectedResult, IDiscoveryResultWithDependencies? actualResult)
         {
             if (expectedResult is null)
             {
@@ -62,50 +66,82 @@ public class DiscoveryWorkerTestBase
             ValidateDependencies(expectedResult.Dependencies, actualResult.Dependencies);
             Assert.Equal(expectedResult.ExpectedDependencyCount ?? expectedResult.Dependencies.Length, actualResult.Dependencies.Length);
         }
+    }
+
+    internal static void ValidateProjectResults(ImmutableArray<ExpectedSdkProjectDiscoveryResult> expectedProjects, ImmutableArray<ProjectDiscoveryResult> actualProjects, ExperimentsManager experimentsManager)
+    {
+        if (expectedProjects.IsDefaultOrEmpty)
+        {
+            return;
+        }
 
-        void ValidateProjectResults(ImmutableArray<ExpectedSdkProjectDiscoveryResult> expectedProjects, ImmutableArray<ProjectDiscoveryResult> actualProjects)
+        foreach (var expectedProject in expectedProjects)
         {
-            if (expectedProjects.IsDefaultOrEmpty)
+            var actualProject = actualProjects.SingleOrDefault(p => p.FilePath.NormalizePathToUnix() == expectedProject.FilePath.NormalizePathToUnix());
+            Assert.True(actualProject is not null, $"Unable to find project with path `{expectedProject.FilePath.NormalizePathToUnix()}` in collection [{string.Join(", ", actualProjects.Select(p => p.FilePath))}]");
+            Assert.Equal(expectedProject.FilePath.NormalizePathToUnix(), actualProject.FilePath.NormalizePathToUnix());
+
+            // some properties are byproducts of the older temporary project discovery process and shouldn't be returned
+            var actualProperties = actualProject.Properties;
+            if (!experimentsManager.UseDirectDiscovery)
             {
-                return;
+                var forbiddenProperties = new HashSet<string>(["TargetFrameworkVersion"], StringComparer.OrdinalIgnoreCase);
+                actualProperties = actualProperties.Where(p => !forbiddenProperties.Contains(p.Name)).ToImmutableArray();
+            }
+
+            AssertEx.Equal(expectedProject.Properties, actualProperties, PropertyComparer.Instance);
+            AssertEx.Equal(expectedProject.TargetFrameworks, actualProject.TargetFrameworks);
+            AssertEx.Equal(expectedProject.ReferencedProjectPaths, actualProject.ReferencedProjectPaths);
+            if (expectedProject.ImportedFiles is not null)
+            {
+                AssertEx.Equal(expectedProject.ImportedFiles.Value.Select(PathHelper.NormalizePathToUnix), actualProject.ImportedFiles.Select(PathHelper.NormalizePathToUnix));
             }
 
-            foreach (var expectedProject in expectedProjects)
+            // some dependencies are byproducts of the older temporary project discovery process and shouldn't be returned
+            var actualDependencies = actualProject.Dependencies;
+            if (!experimentsManager.UseDirectDiscovery)
             {
-                var actualProject = actualProjects.Single(p => p.FilePath.NormalizePathToUnix() == expectedProject.FilePath.NormalizePathToUnix());
-
-                Assert.Equal(expectedProject.FilePath.NormalizePathToUnix(), actualProject.FilePath.NormalizePathToUnix());
-                AssertEx.Equal(expectedProject.Properties, actualProject.Properties, PropertyComparer.Instance);
-                AssertEx.Equal(expectedProject.TargetFrameworks, actualProject.TargetFrameworks);
-                AssertEx.Equal(expectedProject.ReferencedProjectPaths.Select(PathHelper.NormalizePathToUnix), actualProject.ReferencedProjectPaths.Select(PathHelper.NormalizePathToUnix));
-                ValidateDependencies(expectedProject.Dependencies, actualProject.Dependencies);
-                Assert.Equal(expectedProject.ExpectedDependencyCount ?? expectedProject.Dependencies.Length, actualProject.Dependencies.Length);
+                var forbiddenDependencies = new HashSet<string>(["Microsoft.NET.Sdk"], StringComparer.OrdinalIgnoreCase);
+                actualDependencies = actualDependencies.Where(d => !forbiddenDependencies.Contains(d.Name)).ToImmutableArray();
             }
+
+            // some dependencies are byproducts of the test framework and shouldn't be returned to make the tests more deterministic
+            var forbiddenTestDependencies = new HashSet<string>(["Microsoft.NETFramework.ReferenceAssemblies"], StringComparer.OrdinalIgnoreCase);
+            actualDependencies = actualDependencies.Where(d => !forbiddenTestDependencies.Contains(d.Name)).ToImmutableArray();
+
+            ValidateDependencies(expectedProject.Dependencies, actualDependencies);
+            Assert.Equal(expectedProject.ExpectedDependencyCount ?? expectedProject.Dependencies.Length, actualDependencies.Length);
         }
+    }
 
-        void ValidateDirectoryPackagesProps(ExpectedDirectoryPackagesPropsDiscovertyResult? expected, DirectoryPackagesPropsDiscoveryResult? actual)
+    internal static void ValidateDependencies(ImmutableArray<Dependency> expectedDependencies, ImmutableArray<Dependency> actualDependencies)
+    {
+        if (expectedDependencies.IsDefault)
         {
-            ValidateResultWithDependencies(expected, actual);
-            Assert.Equal(expected?.IsTransitivePinningEnabled, actual?.IsTransitivePinningEnabled);
+            return;
         }
 
-        void ValidateDependencies(ImmutableArray<Dependency> expectedDependencies, ImmutableArray<Dependency> actualDependencies)
+        foreach (var expectedDependency in expectedDependencies)
         {
-            if (expectedDependencies.IsDefault)
+            var matchingDependencies = actualDependencies.Where(d =>
             {
-                return;
-            }
-
-            foreach (var expectedDependency in expectedDependencies)
-            {
-                var actualDependency = actualDependencies.Single(d => d.Name == expectedDependency.Name && d.Type == expectedDependency.Type);
-                Assert.Equal(expectedDependency.Name, actualDependency.Name);
-                Assert.Equal(expectedDependency.Version, actualDependency.Version);
-                Assert.Equal(expectedDependency.Type, actualDependency.Type);
-                AssertEx.Equal(expectedDependency.TargetFrameworks, actualDependency.TargetFrameworks);
-                Assert.Equal(expectedDependency.IsDirect, actualDependency.IsDirect);
-                Assert.Equal(expectedDependency.IsTransitive, actualDependency.IsTransitive);
-            }
+                return d.Name == expectedDependency.Name
+                    && d.Type == expectedDependency.Type
+                    && d.Version == expectedDependency.Version
+                    && d.IsDirect == expectedDependency.IsDirect
+                    && d.IsTransitive == expectedDependency.IsTransitive
+                    && d.TargetFrameworks.SequenceEqual(expectedDependency.TargetFrameworks);
+            }).ToArray();
+            Assert.True(matchingDependencies.Length == 1, $"""
+                Unable to find 1 dependency matching; found {matchingDependencies.Length}:
+                    Name: {expectedDependency.Name}
+                    Type: {expectedDependency.Type}
+                    Version: {expectedDependency.Version}
+                    IsDirect: {expectedDependency.IsDirect}
+                    IsTransitive: {expectedDependency.IsTransitive}
+                    TargetFrameworks: {string.Join(", ", expectedDependency.TargetFrameworks ?? [])}
+                Found:{"\n\t"}{string.Join("\n\t", actualDependencies)}
+                """);
         }
     }
 

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Discover/DiscoveryWorkerTests.PackagesConfig.cs

@@ -7,9 +7,10 @@ public partial class DiscoveryWorkerTests
     public class PackagesConfig : DiscoveryWorkerTestBase
     {
         [Fact]
-        public async Task DiscoversDependencies()
+        public async Task DiscoversDependencies_DirectDiscovery()
         {
             await TestDiscoveryAsync(
+                experimentsManager: new ExperimentsManager() { UseDirectDiscovery = true },
                 packages:
                 [
                     MockNuGetPackage.CreateSimplePackage("Package.A", "1.0.0", "net46"),
@@ -25,7 +26,7 @@ public partial class DiscoveryWorkerTests
                         </packages>
                         """),
                     ("myproj.csproj", """
-                        <Project>
+                        <Project Sdk="Microsoft.NET.Sdk">
                           <PropertyGroup>
                             <TargetFramework>net46</TargetFramework>
                           </PropertyGroup>
@@ -40,11 +41,56 @@ public partial class DiscoveryWorkerTests
                         {
                             FilePath = "myproj.csproj",
                             Properties = [
-                                new("TargetFramework", "net46", "myproj.csproj"),
+                                new("TargetFramework", "net46", "myproj.csproj")
                             ],
                             TargetFrameworks = ["net46"],
                             Dependencies = [
-                                new("Microsoft.NETFramework.ReferenceAssemblies", "1.0.3", DependencyType.Unknown, TargetFrameworks: ["net46"], IsTransitive: true),
+                                new("Package.A", "1.0.0", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("Package.B", "2.0.0", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                            ],
+                        }
+                    ],
+                }
+            );
+        }
+
+        [Fact]
+        public async Task DiscoversDependencies_TemporaryProjectDiscovery()
+        {
+            await TestDiscoveryAsync(
+                experimentsManager: new ExperimentsManager() { UseDirectDiscovery = false },
+                packages:
+                [
+                    MockNuGetPackage.CreateSimplePackage("Package.A", "1.0.0", "net46"),
+                    MockNuGetPackage.CreateSimplePackage("Package.B", "2.0.0", "net46"),
+                ],
+                workspacePath: "",
+                files: [
+                    ("packages.config", """
+                        <?xml version="1.0" encoding="utf-8"?>
+                        <packages>
+                          <package id="Package.A" version="1.0.0" targetFramework="net46" />
+                          <package id="Package.B" version="2.0.0" targetFramework="net46" />
+                        </packages>
+                        """),
+                    ("myproj.csproj", """
+                        <Project Sdk="Microsoft.NET.Sdk">
+                          <PropertyGroup>
+                            <TargetFramework>net46</TargetFramework>
+                          </PropertyGroup>
+                        </Project>
+                        """)
+                ],
+                expectedResult: new()
+                {
+                    Path = "",
+                    Projects = [
+                        new()
+                        {
+                            FilePath = "myproj.csproj",
+                            Properties = [new("TargetFramework", "net46", "myproj.csproj")],
+                            TargetFrameworks = ["net46"],
+                            Dependencies = [
                                 new("Package.A", "1.0.0", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
                                 new("Package.B", "2.0.0", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
                             ],

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Discover/DiscoveryWorkerTests.Proj.cs

@@ -12,7 +12,11 @@ public partial class DiscoveryWorkerTests
         public async Task DirsProjExpansion(string itemType)
         {
             await TestDiscoveryAsync(
-                packages: [],
+                packages:
+                [
+                    MockNuGetPackage.CreateSimplePackage("Package.A", "1.0.0", "net8.0"),
+                    MockNuGetPackage.CreateSimplePackage("Package.B", "2.0.0", "net8.0"),
+                ],
                 workspacePath: "dependabot",
                 files:
                 [
@@ -60,7 +64,6 @@ public partial class DiscoveryWorkerTests
                         new()
                         {
                             FilePath = "../src/project1/project1.csproj",
-                            ExpectedDependencyCount = 2,
                             Dependencies =
                             [
                                 new("Package.A", "1.0.0", DependencyType.PackageReference, TargetFrameworks: ["net8.0"], IsDirect: true),
@@ -70,12 +73,10 @@ public partial class DiscoveryWorkerTests
                                 new("TargetFramework", "net8.0", "src/project1/project1.csproj")
                             ],
                             TargetFrameworks = ["net8.0"],
-                            ReferencedProjectPaths = []
                         },
                         new()
                         {
                             FilePath = "../src/project2/project2.csproj",
-                            ExpectedDependencyCount = 2,
                             Dependencies =
                             [
                                 new("Package.B", "2.0.0", DependencyType.PackageReference, TargetFrameworks: ["net8.0"], IsDirect: true),
@@ -85,7 +86,6 @@ public partial class DiscoveryWorkerTests
                                 new("TargetFramework", "net8.0", "src/project2/project2.csproj")
                             ],
                             TargetFrameworks = ["net8.0"],
-                            ReferencedProjectPaths = []
                         }
                     ]
                 }