dependabot-nuget 0.252.0 → 0.254.0

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

@@ -2,6 +2,7 @@ using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
 using System.Text;
 using System.Text.Json;
+using System.Text.Json.Nodes;
 using System.Text.RegularExpressions;
 using System.Xml;
 
@@ -13,6 +14,7 @@ using Microsoft.Build.Locator;
 using Microsoft.Extensions.FileSystemGlobbing;
 
 using NuGet.Configuration;
+using NuGet.Versioning;
 
 using NuGetUpdater.Core.Utilities;
 
@@ -24,106 +26,34 @@ internal static partial class MSBuildHelper
 
     public static bool IsMSBuildRegistered => MSBuildPath.Length > 0;
 
-    static MSBuildHelper()
-    {
-        RegisterMSBuild();
-    }
-
-    public static void RegisterMSBuild()
+    public static void RegisterMSBuild(string currentDirectory, string rootDirectory)
     {
         // Ensure MSBuild types are registered before calling a method that loads the types
         if (!IsMSBuildRegistered)
         {
-            var globalJsonPath = "global.json";
-            var tempGlobalJsonPath = globalJsonPath + Guid.NewGuid().ToString();
-            var globalJsonExists = File.Exists(globalJsonPath);
-            try
+            var candidateDirectories = PathHelper.GetAllDirectoriesToRoot(currentDirectory, rootDirectory);
+            var globalJsonPaths = candidateDirectories.Select(d => Path.Combine(d, "global.json")).Where(File.Exists).Select(p => (p, p + Guid.NewGuid().ToString())).ToArray();
+            foreach (var (globalJsonPath, tempGlobalJsonPath) in globalJsonPaths)
             {
-                if (globalJsonExists)
-                {
-                    Console.WriteLine("Temporarily removing `global.json` for MSBuild detection.");
-                    File.Move(globalJsonPath, tempGlobalJsonPath);
-                }
+                Console.WriteLine($"Temporarily removing `global.json` from `{Path.GetDirectoryName(globalJsonPath)}` for MSBuild detection.");
+                File.Move(globalJsonPath, tempGlobalJsonPath);
+            }
 
+            try
+            {
                 var defaultInstance = MSBuildLocator.QueryVisualStudioInstances().First();
                 MSBuildPath = defaultInstance.MSBuildPath;
                 MSBuildLocator.RegisterInstance(defaultInstance);
             }
             finally
             {
-                if (globalJsonExists)
-                {
-                    Console.WriteLine("Restoring `global.json` after MSBuild detection.");
-                    File.Move(tempGlobalJsonPath, globalJsonPath);
-                }
-            }
-        }
-    }
-
-    public static string[] GetTargetFrameworkMonikers(ImmutableArray<ProjectBuildFile> buildFiles)
-    {
-        HashSet<string> targetFrameworkValues = new(StringComparer.OrdinalIgnoreCase);
-        Dictionary<string, Property> propertyInfo = new(StringComparer.OrdinalIgnoreCase);
-
-        foreach (var buildFile in buildFiles)
-        {
-            var projectRoot = CreateProjectRootElement(buildFile);
-
-            foreach (var property in projectRoot.Properties)
-            {
-                if (property.Name.Equals("TargetFramework", StringComparison.OrdinalIgnoreCase) ||
-                    property.Name.Equals("TargetFrameworks", StringComparison.OrdinalIgnoreCase))
-                {
-                    if (buildFile.IsOutsideBasePath)
-                    {
-                        continue;
-                    }
-
-                    foreach (var tfm in property.Value.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
-                    {
-                        targetFrameworkValues.Add(tfm);
-                    }
-                }
-                else if (property.Name.Equals("TargetFrameworkVersion", StringComparison.OrdinalIgnoreCase))
+                foreach (var (globalJsonpath, tempGlobalJsonPath) in globalJsonPaths)
                 {
-                    if (buildFile.IsOutsideBasePath)
-                    {
-                        continue;
-                    }
-
-                    // For packages.config projects that use TargetFrameworkVersion, we need to convert it to TargetFramework
-                    targetFrameworkValues.Add($"net{property.Value.TrimStart('v').Replace(".", "")}");
+                    Console.WriteLine($"Restoring `global.json` to `{Path.GetDirectoryName(globalJsonpath)}` after MSBuild discovery.");
+                    File.Move(tempGlobalJsonPath, globalJsonpath);
                 }
-                else
-                {
-                    propertyInfo[property.Name] = new(property.Name, property.Value, buildFile.RelativePath);
-                }
-            }
-        }
-
-        HashSet<string> targetFrameworks = new(StringComparer.OrdinalIgnoreCase);
-
-        foreach (var targetFrameworkValue in targetFrameworkValues)
-        {
-            var (resultType, _, tfms, _, errorMessage) =
-                GetEvaluatedValue(targetFrameworkValue, propertyInfo, propertiesToIgnore: ["TargetFramework", "TargetFrameworks"]);
-            if (resultType != EvaluationResultType.Success)
-            {
-                continue;
-            }
-
-            if (string.IsNullOrEmpty(tfms))
-            {
-                continue;
-            }
-
-            foreach (var tfm in tfms.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
-            {
-                targetFrameworks.Add(tfm);
             }
         }
-
-        return targetFrameworks.ToArray();
     }
 
     public static IEnumerable<string> GetProjectPathsFromSolution(string solutionPath)
@@ -379,6 +309,124 @@ internal static partial class MSBuildHelper
         }
     }
 
+    internal static async Task<Dependency[]?> ResolveDependencyConflicts(string repoRoot, string projectPath, string targetFramework, Dependency[] packages, Logger logger)
+    {
+        var tempDirectory = Directory.CreateTempSubdirectory("package-dependency-coherence_");
+        try
+        {
+            var tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages);
+            var (exitCode, stdOut, stdErr) = await ProcessEx.RunAsync("dotnet", $"restore \"{tempProjectPath}\"", workingDirectory: tempDirectory.FullName);
+
+            // simple cases first
+            // if restore failed, nothing we can do
+            if (exitCode != 0)
+            {
+                return null;
+            }
+
+            // if no problems found, just return the current set
+            if (!stdOut.Contains("NU1608"))
+            {
+                return packages;
+            }
+
+            // now it gets complicated; look for the packages with issues
+            MatchCollection matches = PackageIncompatibilityWarningPattern().Matches(stdOut);
+            (string, NuGetVersion)[] badPackagesAndVersions = matches.Select(m => (m.Groups["PackageName"].Value, NuGetVersion.Parse(m.Groups["PackageVersion"].Value))).ToArray();
+            Dictionary<string, HashSet<NuGetVersion>> badPackagesAndCandidateVersionsDictionary = new(StringComparer.OrdinalIgnoreCase);
+
+            // and for each of those packages, find all versions greater than the one that's currently installed
+            foreach ((string packageName, NuGetVersion packageVersion) in badPackagesAndVersions)
+            {
+                // this command dumps a JSON object with all versions of the specified package from all package sources
+                (exitCode, stdOut, stdErr) = await ProcessEx.RunAsync("dotnet", $"package search {packageName} --exact-match --format json", workingDirectory: tempDirectory.FullName);
+                if (exitCode != 0)
+                {
+                    continue;
+                }
+
+                // ensure collection exists
+                if (!badPackagesAndCandidateVersionsDictionary.ContainsKey(packageName))
+                {
+                    badPackagesAndCandidateVersionsDictionary.Add(packageName, new HashSet<NuGetVersion>());
+                }
+
+                HashSet<NuGetVersion> foundVersions = badPackagesAndCandidateVersionsDictionary[packageName];
+
+                var json = JsonHelper.ParseNode(stdOut);
+                if (json?["searchResult"] is JsonArray searchResults)
+                {
+                    foreach (var searchResult in searchResults)
+                    {
+                        if (searchResult?["packages"] is JsonArray packagesArray)
+                        {
+                            foreach (var package in packagesArray)
+                            {
+                                // in 8.0.xxx SDKs, the package version is in the `latestVersion` property, but in 9.0.xxx, it's `version`
+                                var packageVersionProperty = package?["version"] ?? package?["latestVersion"];
+                                if (packageVersionProperty is JsonValue latestVersion &&
+                                    latestVersion.GetValueKind() == JsonValueKind.String &&
+                                    NuGetVersion.TryParse(latestVersion.ToString(), out var nugetVersion) &&
+                                    nugetVersion > packageVersion)
+                                {
+                                    foundVersions.Add(nugetVersion);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // generate all possible combinations
+            (string Key, NuGetVersion v)[][] expandedLists = badPackagesAndCandidateVersionsDictionary.Select(kvp => kvp.Value.Order().Select(v => (kvp.Key, v)).ToArray()).ToArray();
+            IEnumerable<(string PackageName, NuGetVersion PackageVersion)>[] product = expandedLists.CartesianProduct().ToArray();
+
+            // FUTURE WORK: pre-filter individual known package incompatibilities to reduce the number of combinations, e.g., if Package.A v1.0.0
+            // is incompatible with Package.B v2.0.0, then remove _all_ combinations with that pair
+
+            // this is the slow part
+            foreach (IEnumerable<(string PackageName, NuGetVersion PackageVersion)> candidateSet in product)
+            {
+                // rebuild candidate dependency list with the relevant versions
+                Dictionary<string, NuGetVersion> packageVersions = candidateSet.ToDictionary(candidateSet => candidateSet.PackageName, candidateSet => candidateSet.PackageVersion);
+                Dependency[] candidatePackages = packages.Select(p =>
+                {
+                    if (packageVersions.TryGetValue(p.Name, out var version))
+                    {
+                        // create a new dependency with the updated version
+                        return new Dependency(p.Name, version.ToString(), p.Type, IsDevDependency: p.IsDevDependency, IsOverride: p.IsOverride, IsUpdate: p.IsUpdate);
+                    }
+
+                    // not the dependency we're looking for, use whatever it already was in this set
+                    return p;
+                }).ToArray();
+
+                if (await DependenciesAreCoherentAsync(repoRoot, projectPath, targetFramework, candidatePackages, logger))
+                {
+                    // return as soon as we find a coherent set
+                    return candidatePackages;
+                }
+            }
+
+            // no package resolution set found
+            return null;
+        }
+        finally
+        {
+            tempDirectory.Delete(recursive: true);
+        }
+    }
+
+    // fully expand all possible combinations using the algorithm from here:
+    // https://ericlippert.com/2010/06/28/computing-a-cartesian-product-with-linq/
+    private static IEnumerable<IEnumerable<T>> CartesianProduct<T>(this IEnumerable<IEnumerable<T>> sequences)
+    {
+        IEnumerable<IEnumerable<T>> emptyProduct = [[]];
+        return sequences.Aggregate(emptyProduct, (accumulator, sequence) => from accseq in accumulator
+                                                                            from item in sequence
+                                                                            select accseq.Concat([item]));
+    }
+
     private static ProjectRootElement CreateProjectRootElement(ProjectBuildFile buildFile)
     {
         var xmlString = buildFile.Contents.ToFullString();
@@ -569,7 +617,7 @@ internal static partial class MSBuildHelper
         return directoryPackagesPropsPath is not null;
     }
 
-    internal static async Task<ImmutableArray<ProjectBuildFile>> LoadBuildFilesAsync(string repoRootPath, string projectPath, bool includeSdkPropsAndTargets = false)
+    internal static async Task<(ImmutableArray<ProjectBuildFile> ProjectBuildFiles, string[] TargetFrameworks)> LoadBuildFilesAndTargetFrameworksAsync(string repoRootPath, string projectPath)
     {
         var buildFileList = new List<string>
         {
@@ -579,6 +627,7 @@ internal static partial class MSBuildHelper
         // a global.json file might cause problems with the dotnet msbuild command; create a safe version temporarily
         TryGetGlobalJsonPath(repoRootPath, projectPath, out var globalJsonPath);
         var safeGlobalJsonName = $"{globalJsonPath}{Guid.NewGuid()}";
+        HashSet<string> targetFrameworks = new(StringComparer.OrdinalIgnoreCase);
 
         try
         {
@@ -607,16 +656,51 @@ internal static partial class MSBuildHelper
             // load the project even if it imports a file that doesn't exist (e.g. a file that's generated at restore
             // or build time).
             using var projectCollection = new ProjectCollection(); // do this in a one-off instance and don't pollute the global collection
-            var project = Project.FromFile(projectPath, new ProjectOptions
+            Project project = Project.FromFile(projectPath, new ProjectOptions
             {
                 LoadSettings = ProjectLoadSettings.IgnoreMissingImports,
                 ProjectCollection = projectCollection,
             });
             buildFileList.AddRange(project.Imports.Select(i => i.ImportedProject.FullPath.NormalizePathToUnix()));
+
+            // use the MSBuild-evaluated value so we don't have to try to manually parse XML
+            IEnumerable<ProjectProperty> targetFrameworkProperties = project.Properties.Where(p => p.Name.Equals("TargetFramework", StringComparison.OrdinalIgnoreCase)).ToList();
+            IEnumerable<ProjectProperty> targetFrameworksProperties = project.Properties.Where(p => p.Name.Equals("TargetFrameworks", StringComparison.OrdinalIgnoreCase)).ToList();
+            IEnumerable<ProjectProperty> targetFrameworkVersionProperties = project.Properties.Where(p => p.Name.Equals("TargetFrameworkVersion", StringComparison.OrdinalIgnoreCase)).ToList();
+            foreach (ProjectProperty tfm in targetFrameworkProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(tfm.EvaluatedValue))
+                {
+                    targetFrameworks.Add(tfm.EvaluatedValue);
+                }
+            }
+
+            foreach (ProjectProperty tfms in targetFrameworksProperties)
+            {
+                foreach (string tfmValue in tfms.EvaluatedValue.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
+                {
+                    targetFrameworks.Add(tfmValue);
+                }
+            }
+
+            if (targetFrameworks.Count == 0)
+            {
+                // Only try this if we haven't been able to resolve anything yet.  This is because deep in the SDK, a
+                // `TargetFramework` of `netstandard2.0` (eventually) gets turned into `v2.0` and we don't want to
+                // interpret that as a .NET Framework 2.0 project.
+                foreach (ProjectProperty tfvm in targetFrameworkVersionProperties)
+                {
+                    // `v0.0` is an error case where no TFM could be evaluated
+                    if (tfvm.EvaluatedValue != "v0.0")
+                    {
+                        targetFrameworks.Add($"net{tfvm.EvaluatedValue.TrimStart('v').Replace(".", "")}");
+                    }
+                }
+            }
         }
         catch (InvalidProjectFileException)
         {
-            return [];
+            return ([], []);
         }
         finally
         {
@@ -627,18 +711,22 @@ internal static partial class MSBuildHelper
         }
 
         var repoRootPathPrefix = repoRootPath.NormalizePathToUnix() + "/";
-        var buildFiles = includeSdkPropsAndTargets
-            ? buildFileList.Distinct()
-            : buildFileList
-                .Where(f => f.StartsWith(repoRootPathPrefix, StringComparison.OrdinalIgnoreCase))
-                .Distinct();
+        var buildFiles = buildFileList
+            .Where(f => f.StartsWith(repoRootPathPrefix, StringComparison.OrdinalIgnoreCase))
+            .Distinct();
         var result = buildFiles
             .Where(File.Exists)
             .Select(path => ProjectBuildFile.Open(repoRootPath, path))
             .ToImmutableArray();
-        return result;
+        return (result, targetFrameworks.ToArray());
     }
 
     [GeneratedRegex("^\\s*NuGetData::Package=(?<PackageName>[^,]+), Version=(?<PackageVersion>.+)$")]
     private static partial Regex PackagePattern();
+
+    // Example output:
+    //   NU1608: Detected package version outside of dependency constraint: SpecFlow.Tools.MsBuild.Generation 3.3.30 requires SpecFlow(= 3.3.30) but version SpecFlow 3.9.74 was resolved.
+    //                                                          PackageName-|+++++++++++++++++++++++++++++++| |++++|-PackageVersion
+    [GeneratedRegex("NU1608: [^:]+: (?<PackageName>[^ ]+) (?<PackageVersion>[^ ]+)")]
+    private static partial Regex PackageIncompatibilityWarningPattern();
 }

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

@@ -34,20 +34,11 @@ internal static class PathHelper
     public static string GetFullPathFromRelative(string rootPath, string relativePath)
         => Path.GetFullPath(JoinPath(rootPath, relativePath.NormalizePathToUnix()));
 
-    /// <summary>
-    /// Check in every directory from <paramref name="initialPath"/> up to <paramref name="rootPath"/> for the file specified in <paramref name="fileName"/>.
-    /// </summary>
-    /// <returns>The path of the found file or null.</returns>
-    public static string? GetFileInDirectoryOrParent(string initialPath, string rootPath, string fileName, bool caseSensitive = true)
+    public static string[] GetAllDirectoriesToRoot(string initialDirectoryPath, string rootDirectoryPath)
     {
-        if (File.Exists(initialPath))
-        {
-            initialPath = Path.GetDirectoryName(initialPath)!;
-        }
-
         var candidatePaths = new List<string>();
-        var rootDirectory = new DirectoryInfo(rootPath);
-        var candidateDirectory = new DirectoryInfo(initialPath);
+        var rootDirectory = new DirectoryInfo(rootDirectoryPath);
+        var candidateDirectory = new DirectoryInfo(initialDirectoryPath);
         while (candidateDirectory.FullName != rootDirectory.FullName)
         {
             candidatePaths.Add(candidateDirectory.FullName);
@@ -58,8 +49,22 @@ internal static class PathHelper
             }
         }
 
-        candidatePaths.Add(rootPath);
+        candidatePaths.Add(rootDirectoryPath);
+        return candidatePaths.ToArray();
+    }
+
+    /// <summary>
+    /// Check in every directory from <paramref name="initialPath"/> up to <paramref name="rootPath"/> for the file specified in <paramref name="fileName"/>.
+    /// </summary>
+    /// <returns>The path of the found file or null.</returns>
+    public static string? GetFileInDirectoryOrParent(string initialPath, string rootPath, string fileName, bool caseSensitive = true)
+    {
+        if (File.Exists(initialPath))
+        {
+            initialPath = Path.GetDirectoryName(initialPath)!;
+        }
 
+        var candidatePaths = GetAllDirectoriesToRoot(initialPath, rootPath);
         foreach (var candidatePath in candidatePaths)
         {
             try

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

@@ -1,4 +1,5 @@
 using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
 using System.Text.Json;
 
 using NuGetUpdater.Core.Discover;
@@ -29,7 +30,7 @@ public class DiscoveryWorkerTestBase
     protected static void ValidateWorkspaceResult(ExpectedWorkspaceDiscoveryResult expectedResult, WorkspaceDiscoveryResult actualResult)
     {
         Assert.NotNull(actualResult);
-        Assert.Equal(expectedResult.FilePath, actualResult.FilePath);
+        Assert.Equal(expectedResult.FilePath.NormalizePathToUnix(), actualResult.FilePath.NormalizePathToUnix());
         ValidateDirectoryPackagesProps(expectedResult.DirectoryPackagesProps, actualResult.DirectoryPackagesProps);
         ValidateResultWithDependencies(expectedResult.GlobalJson, actualResult.GlobalJson);
         ValidateResultWithDependencies(expectedResult.DotNetToolsJson, actualResult.DotNetToolsJson);
@@ -50,7 +51,7 @@ public class DiscoveryWorkerTestBase
                 Assert.NotNull(actualResult);
             }
 
-            Assert.Equal(expectedResult.FilePath, actualResult.FilePath);
+            Assert.Equal(expectedResult.FilePath.NormalizePathToUnix(), actualResult.FilePath.NormalizePathToUnix());
             ValidateDependencies(expectedResult.Dependencies, actualResult.Dependencies);
             Assert.Equal(expectedResult.ExpectedDependencyCount ?? expectedResult.Dependencies.Length, actualResult.Dependencies.Length);
         }
@@ -64,12 +65,12 @@ public class DiscoveryWorkerTestBase
 
             foreach (var expectedProject in expectedProjects)
             {
-                var actualProject = actualProjects.Single(p => p.FilePath == expectedProject.FilePath);
+                var actualProject = actualProjects.Single(p => p.FilePath.NormalizePathToUnix() == expectedProject.FilePath.NormalizePathToUnix());
 
-                Assert.Equal(expectedProject.FilePath, actualProject.FilePath);
-                AssertEx.Equal(expectedProject.Properties, actualProject.Properties);
+                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, actualProject.ReferencedProjectPaths);
+                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);
             }
@@ -114,4 +115,21 @@ public class DiscoveryWorkerTestBase
         var resultJson = await File.ReadAllTextAsync(resultPath);
         return JsonSerializer.Deserialize<WorkspaceDiscoveryResult>(resultJson, DiscoveryWorker.SerializerOptions)!;
     }
+
+    internal class PropertyComparer : IEqualityComparer<Property>
+    {
+        public static PropertyComparer Instance { get; } = new();
+
+        public bool Equals(Property? x, Property? y)
+        {
+            return x?.Name == y?.Name &&
+                   x?.Value == y?.Value &&
+                   x?.SourceFilePath.NormalizePathToUnix() == y?.SourceFilePath.NormalizePathToUnix();
+        }
+
+        public int GetHashCode([DisallowNull] Property obj)
+        {
+            throw new NotImplementedException();
+        }
+    }
 }

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

@@ -25,11 +25,14 @@ public partial class DiscoveryWorkerTests
                           <package id="NuGet.Core" version="2.11.1" targetFramework="net46" />
                           <package id="NuGet.Server" version="2.11.2" targetFramework="net46" />
                           <package id="RouteMagic" version="1.3" targetFramework="net46" />
-                          <package id="WebActivatorEx" version="2.1.0" targetFramework="net46"></package>
+                          <package id="WebActivatorEx" version="2.1.0" targetFramework="net46" />
                         </packages>
                         """),
                     ("myproj.csproj", """
                         <Project>
+                          <PropertyGroup>
+                            <TargetFramework>net46</TargetFramework>
+                          </PropertyGroup>
                         </Project>
                         """)
                 ],
@@ -40,16 +43,21 @@ public partial class DiscoveryWorkerTests
                         new()
                         {
                             FilePath = "myproj.csproj",
+                            Properties = [
+                                new("TargetFramework", "net46", "myproj.csproj"),
+                            ],
+                            TargetFrameworks = ["net46"],
                             Dependencies = [
-                                new("Microsoft.CodeDom.Providers.DotNetCompilerPlatform", "1.0.0", DependencyType.PackagesConfig, TargetFrameworks: []),
-                                new("Microsoft.Net.Compilers", "1.0.1", DependencyType.PackagesConfig, TargetFrameworks: []),
-                                new("Microsoft.Web.Infrastructure", "1.0.0.0", DependencyType.PackagesConfig, TargetFrameworks: []),
-                                new("Microsoft.Web.Xdt", "2.1.1", DependencyType.PackagesConfig, TargetFrameworks: []),
-                                new("Newtonsoft.Json", "8.0.3", DependencyType.PackagesConfig, TargetFrameworks: []),
-                                new("NuGet.Core", "2.11.1", DependencyType.PackagesConfig, TargetFrameworks: []),
-                                new("NuGet.Server", "2.11.2", DependencyType.PackagesConfig, TargetFrameworks: []),
-                                new("RouteMagic", "1.3", DependencyType.PackagesConfig, TargetFrameworks: []),
-                                new("WebActivatorEx", "2.1.0", DependencyType.PackagesConfig, TargetFrameworks: []),
+                                new("Microsoft.NETFramework.ReferenceAssemblies", "1.0.3", DependencyType.Unknown, TargetFrameworks: ["net46"], IsTransitive: true),
+                                new("Microsoft.CodeDom.Providers.DotNetCompilerPlatform", "1.0.0", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("Microsoft.Net.Compilers", "1.0.1", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("Microsoft.Web.Infrastructure", "1.0.0.0", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("Microsoft.Web.Xdt", "2.1.1", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("Newtonsoft.Json", "8.0.3", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("NuGet.Core", "2.11.1", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("NuGet.Server", "2.11.2", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("RouteMagic", "1.3", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("WebActivatorEx", "2.1.0", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
                             ],
                         }
                     ],

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

@@ -376,5 +376,30 @@ public partial class DiscoveryWorkerTests
                     ],
                 });
         }
+
+        [Fact]
+
+        public async Task NoDependenciesReturnedIfNoTargetFrameworkCanBeResolved()
+        {
+            await TestDiscoveryAsync(
+                workspacePath: "",
+                files: [
+                    ("myproj.csproj", """
+                        <Project Sdk="Microsoft.NET.Sdk">
+                          <PropertyGroup>
+                            <TargetFramework>$(SomeCommonTfmThatCannotBeResolved)</TargetFramework>
+                          </PropertyGroup>
+                          <ItemGroup>
+                            <PackageReference Include="Some.Package" Version="1.2.3" />
+                          </ItemGroup>
+                        </Project>
+                        """)
+                ],
+                expectedResult: new()
+                {
+                    FilePath = "",
+                    Projects = []
+                });
+        }
     }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/TestBase.cs

@@ -0,0 +1,10 @@
+namespace NuGetUpdater.Core.Test
+{
+    public abstract class TestBase
+    {
+        protected TestBase()
+        {
+            MSBuildHelper.RegisterMSBuild(Environment.CurrentDirectory, Environment.CurrentDirectory);
+        }
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/PackagesConfigUpdaterTests.cs

@@ -1,16 +1,9 @@
-using System.Collections.Generic;
-
 using Xunit;
 
 namespace NuGetUpdater.Core.Test.Update;
 
-public class PackagesConfigUpdaterTests
+public class PackagesConfigUpdaterTests : TestBase
 {
-    public PackagesConfigUpdaterTests()
-    {
-        MSBuildHelper.RegisterMSBuild();
-    }
-
     [Theory]
     [MemberData(nameof(PackagesDirectoryPathTestData))]
     public void PathToPackagesDirectoryCanBeDetermined(string projectContents, string dependencyName, string dependencyVersion, string expectedPackagesDirectoryPath)

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/UpdateWorkerTestBase.cs

@@ -10,7 +10,7 @@ namespace NuGetUpdater.Core.Test.Update;
 using TestFile = (string Path, string Content);
 using TestProject = (string Path, string Content, Guid ProjectId);
 
-public abstract class UpdateWorkerTestBase
+public abstract class UpdateWorkerTestBase : TestBase
 {
     protected static Task TestNoChange(
         string dependencyName,

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/UpdateWorkerTests.DirsProj.cs

@@ -10,11 +10,6 @@ public partial class UpdateWorkerTests
 {
     public class DirsProj : UpdateWorkerTestBase
     {
-        public DirsProj()
-        {
-            MSBuildHelper.RegisterMSBuild();
-        }
-
         [Fact]
         public async Task UpdateSingleDependencyInDirsProj()
         {

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/UpdateWorkerTests.DotNetTools.cs

@@ -8,11 +8,6 @@ public partial class UpdateWorkerTests
 {
     public class DotNetTools : UpdateWorkerTestBase
     {
-        public DotNetTools()
-        {
-            MSBuildHelper.RegisterMSBuild();
-        }
-
         [Fact]
         public async Task NoChangeWhenDotNetToolsJsonNotFound()
         {

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/UpdateWorkerTests.GlobalJson.cs

@@ -8,11 +8,6 @@ public partial class UpdateWorkerTests
 {
     public class GlobalJson : UpdateWorkerTestBase
     {
-        public GlobalJson()
-        {
-            MSBuildHelper.RegisterMSBuild();
-        }
-
         [Fact]
         public async Task NoChangeWhenGlobalJsonNotFound()
         {

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/UpdateWorkerTests.Mixed.cs

@@ -8,11 +8,6 @@ public partial class UpdateWorkerTests
 {
     public class Mixed : UpdateWorkerTestBase
     {
-        public Mixed()
-        {
-            MSBuildHelper.RegisterMSBuild();
-        }
-
         [Fact]
         public async Task ForPackagesProject_UpdatePackageReference_InBuildProps()
         {