dependabot-nuget 0.287.0 → 0.289.0

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

@@ -32,6 +32,9 @@ public partial class AnalyzeWorkerTests : AnalyzeWorkerTestBase
                         Dependencies = [
                             new("Some.Package", "1.0.0", DependencyType.PackageReference),
                         ],
+                        ReferencedProjectPaths = [],
+                        ImportedFiles = [],
+                        AdditionalFiles = [],
                     },
                 ],
             },
@@ -80,6 +83,9 @@ public partial class AnalyzeWorkerTests : AnalyzeWorkerTestBase
                             new("Some.Package", "4.0.1", DependencyType.PackageReference),
                             new("Some.Transitive.Dependency", "4.0.1", DependencyType.PackageReference),
                         ],
+                        ReferencedProjectPaths = [],
+                        ImportedFiles = [],
+                        AdditionalFiles = [],
                     },
                 ],
             },
@@ -129,6 +135,9 @@ public partial class AnalyzeWorkerTests : AnalyzeWorkerTestBase
                         Dependencies = [
                             new("Some.Transitive.Dependency", "4.0.1", DependencyType.PackageReference, EvaluationResult: evaluationResult, TargetFrameworks: ["net8.0"]),
                         ],
+                        ReferencedProjectPaths = [],
+                        ImportedFiles = [],
+                        AdditionalFiles = [],
                     },
                     new()
                     {
@@ -137,6 +146,9 @@ public partial class AnalyzeWorkerTests : AnalyzeWorkerTestBase
                         Dependencies = [
                             new("Some.Package", "4.0.1", DependencyType.PackageReference, EvaluationResult: evaluationResult, TargetFrameworks: ["net8.0"]),
                         ],
+                        ReferencedProjectPaths = [],
+                        ImportedFiles = [],
+                        AdditionalFiles = [],
                     },
                 ],
             },
@@ -187,6 +199,9 @@ public partial class AnalyzeWorkerTests : AnalyzeWorkerTestBase
                         Dependencies = [
                             new("Package.A", "4.5.0", DependencyType.PackageReference, EvaluationResult: evaluationResult, TargetFrameworks: ["net8.0"]),
                         ],
+                        ReferencedProjectPaths = [],
+                        ImportedFiles = [],
+                        AdditionalFiles = [],
                     },
                     new()
                     {
@@ -195,6 +210,9 @@ public partial class AnalyzeWorkerTests : AnalyzeWorkerTestBase
                         Dependencies = [
                             new("Package.B", "4.5.0", DependencyType.PackageReference, EvaluationResult: evaluationResult, TargetFrameworks: ["net8.0"]),
                         ],
+                        ReferencedProjectPaths = [],
+                        ImportedFiles = [],
+                        AdditionalFiles = [],
                     },
                 ],
             },
@@ -241,6 +259,9 @@ public partial class AnalyzeWorkerTests : AnalyzeWorkerTestBase
                         Dependencies = [
                             new("Some.Transitive.Dependency", "$(MissingPackageVersion)", DependencyType.PackageReference, EvaluationResult: new EvaluationResult(EvaluationResultType.PropertyNotFound, "$(MissingPackageVersion)", "$(MissingPackageVersion)", "$(MissingPackageVersion)", ErrorMessage: null)),
                         ],
+                        ReferencedProjectPaths = [],
+                        ImportedFiles = [],
+                        AdditionalFiles = [],
                     },
                 ],
             },
@@ -281,6 +302,9 @@ public partial class AnalyzeWorkerTests : AnalyzeWorkerTestBase
                         Dependencies = [
                             new("Some.Package", "1.0.0", DependencyType.PackageReference), // this was found in the source, but doesn't exist in any feed
                         ],
+                        ReferencedProjectPaths = [],
+                        ImportedFiles = [],
+                        AdditionalFiles = [],
                     },
                 ],
             },
@@ -326,6 +350,9 @@ public partial class AnalyzeWorkerTests : AnalyzeWorkerTestBase
                         Dependencies = [
                             new("Some.Transitive.Dependency", "4.0.1", DependencyType.PackageReference),
                         ],
+                        ReferencedProjectPaths = [],
+                        ImportedFiles = [],
+                        AdditionalFiles = [],
                     },
                 ],
             },
@@ -347,6 +374,62 @@ 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"]),
+                        ],
+                        ReferencedProjectPaths = [],
+                        ImportedFiles = [],
+                        AdditionalFiles = [],
+                    },
+                    new()
+                    {
+                        FilePath = "projectb/projectb.csproj",
+                        TargetFrameworks = ["NET8.0"],
+                        Dependencies = [
+                            new("Some.Package", "1.0.0", DependencyType.PackageReference, TargetFrameworks: ["net8.0"]),
+                        ],
+                        ReferencedProjectPaths = [],
+                        ImportedFiles = [],
+                        AdditionalFiles = [],
+                    }
+                ]
+            },
+            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()
     {
@@ -368,6 +451,9 @@ public partial class AnalyzeWorkerTests : AnalyzeWorkerTestBase
                         Dependencies = [
                             new("Some.Package", "1.0.0", DependencyType.PackageReference),
                         ],
+                        ReferencedProjectPaths = [],
+                        ImportedFiles = [],
+                        AdditionalFiles = [],
                     },
                 ],
             },
@@ -535,7 +621,10 @@ public partial class AnalyzeWorkerTests : AnalyzeWorkerTestBase
                         Dependencies =
                         [
                             new("Some.Package", "1.0.0", DependencyType.PackageReference),
-                        ]
+                        ],
+                        ReferencedProjectPaths = [],
+                        ImportedFiles = [],
+                        AdditionalFiles = [],
                     }
                 ]
             },
@@ -704,7 +793,10 @@ public partial class AnalyzeWorkerTests : AnalyzeWorkerTestBase
                         Dependencies =
                         [
                             new("Some.Package", "1.0.0", DependencyType.PackageReference),
-                        ]
+                        ],
+                        ReferencedProjectPaths = [],
+                        ImportedFiles = [],
+                        AdditionalFiles = [],
                     }
                 ]
             },
@@ -889,7 +981,10 @@ public partial class AnalyzeWorkerTests : AnalyzeWorkerTestBase
                         Dependencies =
                         [
                             new("Some.Package", "1.0.0", DependencyType.PackageReference),
-                        ]
+                        ],
+                        ReferencedProjectPaths = [],
+                        ImportedFiles = [],
+                        AdditionalFiles = [],
                     }
                 ]
             },
@@ -999,6 +1094,9 @@ public partial class AnalyzeWorkerTests : AnalyzeWorkerTestBase
                         Dependencies = [
                             new("Some.Package", "1.2.3", DependencyType.PackageReference),
                         ],
+                        ReferencedProjectPaths = [],
+                        ImportedFiles = [],
+                        AdditionalFiles = [],
                     }
                 ]
             },
@@ -1117,6 +1215,9 @@ public partial class AnalyzeWorkerTests : AnalyzeWorkerTestBase
                         Dependencies = [
                             new("Some.Package", "1.0.0", DependencyType.PackageReference),
                         ],
+                        ReferencedProjectPaths = [],
+                        ImportedFiles = [],
+                        AdditionalFiles = [],
                     }
                 ]
             },
@@ -1137,4 +1238,35 @@ public partial class AnalyzeWorkerTests : AnalyzeWorkerTestBase
             }
         );
     }
+
+    [Fact]
+    public void DeserializeDependencyInfo_UnsupportedIgnoredVersionsAreIgnored()
+    {
+        // arrange
+        // "1.0.0.pre.rc2" isn't a valid NuGet version; ignore that requirement
+        var json = """
+            {
+                "Name": "Some.Package",
+                "Version": "1.10.0",
+                "IsVulnerable": false,
+                "IgnoredVersions": [
+                    "> 1.0.0.pre.rc2, < 2",
+                    "< 1.0.1"
+                ],
+                "Vulnerabilities": []
+            }
+            """;
+
+        // act
+        var dependencyInfo = AnalyzeWorker.DeserializeDependencyInfo(json);
+
+        // assert
+        Assert.NotNull(dependencyInfo);
+        Assert.Equal("Some.Package", dependencyInfo.Name);
+        Assert.Equal("1.10.0", dependencyInfo.Version);
+        Assert.False(dependencyInfo.IsVulnerable);
+        Assert.Single(dependencyInfo.IgnoredVersions);
+        Assert.Equal("< 1.0.1", dependencyInfo.IgnoredVersions.Single().ToString());
+        Assert.Empty(dependencyInfo.Vulnerabilities);
+    }
 }

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,42 @@ 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);
         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 +65,80 @@ 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();
             }
 
-            foreach (var expectedProject in expectedProjects)
+            AssertEx.Equal(expectedProject.Properties, actualProperties, PropertyComparer.Instance);
+            AssertEx.Equal(expectedProject.TargetFrameworks, actualProject.TargetFrameworks);
+            AssertEx.Equal(expectedProject.ReferencedProjectPaths, actualProject.ReferencedProjectPaths);
+            AssertEx.Equal(expectedProject.ImportedFiles, actualProject.ImportedFiles);
+            AssertEx.Equal(expectedProject.AdditionalFiles, actualProject.AdditionalFiles);
+
+            // 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)
-            {
-                return;
-            }
-
-            foreach (var expectedDependency in expectedDependencies)
+            var matchingDependencies = actualDependencies.Where(d =>
             {
-                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,10 +26,13 @@ public partial class DiscoveryWorkerTests
                         </packages>
                         """),
                     ("myproj.csproj", """
-                        <Project>
+                        <Project Sdk="Microsoft.NET.Sdk">
                           <PropertyGroup>
                             <TargetFramework>net46</TargetFramework>
                           </PropertyGroup>
+                          <ItemGroup>
+                            <None Include="packages.config" />
+                          </ItemGroup>
                         </Project>
                         """)
                 ],
@@ -40,14 +44,72 @@ 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"]),
                             ],
+                            ReferencedProjectPaths = [],
+                            ImportedFiles = [],
+                            AdditionalFiles = [
+                                "packages.config"
+                            ],
+                        }
+                    ],
+                }
+            );
+        }
+
+        [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>
+                          <ItemGroup>
+                            <None Include="packages.config" />
+                          </ItemGroup>
+                        </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"]),
+                            ],
+                            ReferencedProjectPaths = [],
+                            ImportedFiles = [],
+                            AdditionalFiles = [
+                                "packages.config"
+                            ],
                         }
                     ],
                 }

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,13 @@ public partial class DiscoveryWorkerTests
                                 new("TargetFramework", "net8.0", "src/project1/project1.csproj")
                             ],
                             TargetFrameworks = ["net8.0"],
-                            ReferencedProjectPaths = []
+                            ReferencedProjectPaths = [],
+                            ImportedFiles = [],
+                            AdditionalFiles = [],
                         },
                         new()
                         {
                             FilePath = "../src/project2/project2.csproj",
-                            ExpectedDependencyCount = 2,
                             Dependencies =
                             [
                                 new("Package.B", "2.0.0", DependencyType.PackageReference, TargetFrameworks: ["net8.0"], IsDirect: true),
@@ -85,7 +89,9 @@ public partial class DiscoveryWorkerTests
                                 new("TargetFramework", "net8.0", "src/project2/project2.csproj")
                             ],
                             TargetFrameworks = ["net8.0"],
-                            ReferencedProjectPaths = []
+                            ReferencedProjectPaths = [],
+                            ImportedFiles = [],
+                            AdditionalFiles = [],
                         }
                     ]
                 }