dependabot-nuget 0.288.0 → 0.290.0

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

@@ -136,7 +136,7 @@ public class PackageManager
     }
 
     // Method to get the dependencies of a package
-    public async Task<List<PackageToUpdate>> GetDependenciesAsync(PackageToUpdate package, string targetFramework, string projectDirectory)
+    public async Task<List<PackageToUpdate>> GetDependenciesAsync(PackageToUpdate package, string targetFramework, string projectDirectory, ILogger logger)
     {
         if (!NuGetVersion.TryParse(package.NewVersion, out var otherVersion))
         {
@@ -235,24 +235,24 @@ public class PackageManager
             }
             else
             {
-                Console.WriteLine("No compatible framework found.");
+                logger.Info("No compatible framework found.");
             }
         }
         catch (HttpRequestException ex)
         {
-            Console.WriteLine($"HTTP error occurred: {ex.Message}");
+            logger.Error($"HTTP error occurred: {ex.Message}");
         }
         catch (ArgumentNullException ex)
         {
-            Console.WriteLine($"Argument is null error: {ex.ParamName}, {ex.Message}");
+            logger.Error($"Argument is null error: {ex.ParamName}, {ex.Message}");
         }
         catch (InvalidOperationException ex)
         {
-            Console.WriteLine($"Invalid operation exception: {ex.Message}");
+            logger.Error($"Invalid operation exception: {ex.Message}");
         }
         catch (Exception ex)
         {
-            Console.WriteLine($"An error occurred: {ex.Message}");
+            logger.Error($"An error occurred: {ex.Message}");
         }
 
         return dependencyList;
@@ -287,12 +287,12 @@ public class PackageManager
     }
 
     // Method to get the dependencies of a package and add them as a dependency
-    public async Task PopulatePackageDependenciesAsync(List<PackageToUpdate> packages, string targetFramework, string projectDirectory)
+    public async Task PopulatePackageDependenciesAsync(List<PackageToUpdate> packages, string targetFramework, string projectDirectory, ILogger logger)
     {
         // Loop through each package and get their dependencies
         foreach (PackageToUpdate package in packages)
         {
-            List<PackageToUpdate> dependencies = await GetDependenciesAsync(package, targetFramework, projectDirectory);
+            List<PackageToUpdate> dependencies = await GetDependenciesAsync(package, targetFramework, projectDirectory, logger);
 
             if (dependencies == null)
             {
@@ -366,7 +366,7 @@ public class PackageManager
                 package.CurrentVersion = package.NewVersion;
 
                 // Check if the current package has dependencies 
-                List<PackageToUpdate> dependencyList = await GetDependenciesAsync(package, targetFramework, projectDirectory);
+                List<PackageToUpdate> dependencyList = await GetDependenciesAsync(package, targetFramework, projectDirectory, logger);
 
                 // If there are dependencies
                 if (dependencyList != null)
@@ -426,7 +426,7 @@ public class PackageManager
 
                 foreach (PackageToUpdate parent in parentPackages)
                 {
-                    bool isCompatible = await IsCompatibleAsync(parent, package, targetFramework, projectDirectory);
+                    bool isCompatible = await IsCompatibleAsync(parent, package, targetFramework, projectDirectory, logger);
 
                     // If the parent and package are not compatible
                     if (!isCompatible)
@@ -446,7 +446,7 @@ public class PackageManager
                     // If it's compatible and the package you updated wasn't in the existing package, check if the parent's dependencies version is the same as the current version
                     else if (isCompatible == true && inExisting == false)
                     {
-                        List<PackageToUpdate> dependencyListParent = await GetDependenciesAsync(parent, targetFramework, projectDirectory);
+                        List<PackageToUpdate> dependencyListParent = await GetDependenciesAsync(parent, targetFramework, projectDirectory, logger);
 
                         PackageToUpdate parentDependency = dependencyListParent.FirstOrDefault(p => string.Compare(p.PackageName, package.PackageName, StringComparison.OrdinalIgnoreCase) == 0);
 
@@ -478,7 +478,7 @@ public class PackageManager
                                 parent.NewVersion = parentVersion;
 
                                 // Check if the parent needs to be updated since the child isn't in the existing package list  and the parent can update to a newer version to remove the dependency
-                                List<PackageToUpdate> dependencyListParentTemp = await GetDependenciesAsync(parent, targetFramework, projectDirectory);
+                                List<PackageToUpdate> dependencyListParentTemp = await GetDependenciesAsync(parent, targetFramework, projectDirectory, logger);
                                 PackageToUpdate parentDependencyTemp = dependencyListParentTemp.FirstOrDefault(p => string.Compare(p.PackageName, package.PackageName, StringComparison.OrdinalIgnoreCase) == 0);
 
                                 // If the newer package version of the parent has the same version as the parent's previous dependency, update
@@ -499,7 +499,7 @@ public class PackageManager
 
             else
             {
-                Console.WriteLine("Current version is >= latest version");
+                logger.Info("Current version is >= latest version");
             }
         }
         catch
@@ -511,10 +511,10 @@ public class PackageManager
     }
 
     // Method to determine if a parent and child are compatible with their versions
-    public async Task<bool> IsCompatibleAsync(PackageToUpdate parent, PackageToUpdate child, string targetFramework, string projectDirectory)
+    public async Task<bool> IsCompatibleAsync(PackageToUpdate parent, PackageToUpdate child, string targetFramework, string projectDirectory, ILogger logger)
     {
         // Get the dependencies of the parent
-        List<PackageToUpdate> dependencies = await GetDependenciesAsync(parent, targetFramework, projectDirectory);
+        List<PackageToUpdate> dependencies = await GetDependenciesAsync(parent, targetFramework, projectDirectory, logger);
 
         foreach (PackageToUpdate dependency in dependencies)
         {
@@ -613,7 +613,7 @@ public class PackageManager
             }
 
             // Check if there's compatibility with parent and dependency
-            if (await IsCompatibleAsync(possibleParent, possibleDependency, targetFramework, nugetContext.CurrentDirectory))
+            if (await IsCompatibleAsync(possibleParent, possibleDependency, targetFramework, nugetContext.CurrentDirectory, logger))
             {
                 // Check if parents are compatible, recursively
                 if (await AreAllParentsCompatibleAsync(existingPackages, possibleParent, targetFramework, nugetContext.CurrentDirectory, logger))
@@ -641,7 +641,7 @@ public class PackageManager
         foreach (PackageToUpdate parent in parentPackages)
         {
             // Check compatibility between the possibleParent and current parent
-            bool isCompatible = await IsCompatibleAsync(parent, possibleParent, targetFramework, projectDirectory);
+            bool isCompatible = await IsCompatibleAsync(parent, possibleParent, targetFramework, projectDirectory, logger);
 
             // If the possibleParent and parent are not compatible
             if (!isCompatible)
@@ -668,7 +668,7 @@ public class PackageManager
     }
 
     // Method to update the existing packages with new version of the desired packages to update
-    public void UpdateExistingPackagesWithNewVersions(List<PackageToUpdate> existingPackages, List<PackageToUpdate> packagesToUpdate)
+    public void UpdateExistingPackagesWithNewVersions(List<PackageToUpdate> existingPackages, List<PackageToUpdate> packagesToUpdate, ILogger logger)
     {
         foreach (PackageToUpdate packageToUpdate in packagesToUpdate)
         {
@@ -680,7 +680,7 @@ public class PackageManager
             }
             else
             {
-                Console.WriteLine($"Package {packageToUpdate.PackageName} not found in existing packages");
+                logger.Info($"Package {packageToUpdate.PackageName} not found in existing packages");
             }
         }
     }

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

@@ -2,5 +2,15 @@ namespace NuGetUpdater.Core;
 
 public interface ILogger
 {
-    void Log(string message);
+    void LogRaw(string message);
+}
+
+public static class LoggerExtensions
+{
+    public static void Info(this ILogger logger, string message) => logger.LogWithLevel("INFO", message);
+    public static void Warn(this ILogger logger, string message) => logger.LogWithLevel("WARN", message);
+    public static void Error(this ILogger logger, string message) => logger.LogWithLevel("ERROR", message);
+
+    private static void LogWithLevel(this ILogger logger, string level, string message) => logger.LogRaw($"{GetCurrentTimestamp()} {level} {message}");
+    private static string GetCurrentTimestamp() => DateTime.UtcNow.ToString("yyyy/MM/dd HH:mm:ss");
 }

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

@@ -11,6 +11,7 @@ namespace NuGetUpdater.Core.Utilities
         public static JsonDocumentOptions DocumentOptions { get; } = new JsonDocumentOptions
         {
             CommentHandling = JsonCommentHandling.Skip,
+            AllowTrailingCommas = true,
         };
 
         public static JsonNode? ParseNode(string content)
@@ -24,6 +25,7 @@ namespace NuGetUpdater.Core.Utilities
             var readerOptions = new JsonReaderOptions
             {
                 CommentHandling = JsonCommentHandling.Allow,
+                AllowTrailingCommas = true,
             };
             var bytes = Encoding.UTF8.GetBytes(json);
             var reader = new Utf8JsonReader(bytes, readerOptions);

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

@@ -51,7 +51,7 @@ internal static partial class MSBuildHelper
         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)
         {
-            logger.Log($"Temporarily removing `global.json` from `{Path.GetDirectoryName(globalJsonPath)}`{(retainMSBuildSdks ? " and retaining MSBuild SDK declarations" : string.Empty)}.");
+            logger.Info($"Temporarily removing `global.json` from `{Path.GetDirectoryName(globalJsonPath)}`{(retainMSBuildSdks ? " and retaining MSBuild SDK declarations" : string.Empty)}.");
             File.Move(globalJsonPath, tempGlobalJsonPath);
             if (retainMSBuildSdks)
             {
@@ -80,7 +80,7 @@ internal static partial class MSBuildHelper
         {
             foreach (var (globalJsonpath, tempGlobalJsonPath) in globalJsonPaths)
             {
-                logger.Log($"Restoring `global.json` to `{Path.GetDirectoryName(globalJsonpath)}`.");
+                logger.Info($"Restoring `global.json` to `{Path.GetDirectoryName(globalJsonpath)}`.");
                 File.Move(tempGlobalJsonPath, globalJsonpath, overwrite: retainMSBuildSdks);
             }
         }
@@ -327,7 +327,7 @@ internal static partial class MSBuildHelper
         var tempDirectory = Directory.CreateTempSubdirectory("package-dependency-coherence_");
         try
         {
-            var tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages);
+            var tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages, logger);
             var (exitCode, stdOut, stdErr) = await ProcessEx.RunAsync("dotnet", ["restore", tempProjectPath], workingDirectory: tempDirectory.FullName);
 
             // NU1608: Detected package version outside of dependency constraint
@@ -347,7 +347,7 @@ internal static partial class MSBuildHelper
 
         try
         {
-            string tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages);
+            string tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages, logger);
             var (exitCode, stdOut, stdErr) = await ProcessEx.RunAsync("dotnet", ["restore", tempProjectPath], workingDirectory: tempDirectory.FullName);
 
             // Add Dependency[] packages to List<PackageToUpdate> existingPackages
@@ -398,10 +398,10 @@ internal static partial class MSBuildHelper
             if (added == true)
             {
                 // Add existing versions to existing list
-                packageManager.UpdateExistingPackagesWithNewVersions(existingDuplicate, packagesToUpdate);
+                packageManager.UpdateExistingPackagesWithNewVersions(existingDuplicate, packagesToUpdate, logger);
 
                 // Make relationships
-                await packageManager.PopulatePackageDependenciesAsync(existingDuplicate, targetFramework, Path.GetDirectoryName(projectPath));
+                await packageManager.PopulatePackageDependenciesAsync(existingDuplicate, targetFramework, Path.GetDirectoryName(projectPath), logger);
 
                 // Update all to new versions
                 foreach (var package in existingDuplicate)
@@ -414,10 +414,10 @@ internal static partial class MSBuildHelper
             else
             {
                 // Add existing versions to existing list
-                packageManager.UpdateExistingPackagesWithNewVersions(existingPackages, packagesToUpdate);
+                packageManager.UpdateExistingPackagesWithNewVersions(existingPackages, packagesToUpdate, logger);
 
                 // Make relationships
-                await packageManager.PopulatePackageDependenciesAsync(existingPackages, targetFramework, Path.GetDirectoryName(projectPath));
+                await packageManager.PopulatePackageDependenciesAsync(existingPackages, targetFramework, Path.GetDirectoryName(projectPath), logger);
 
                 // Update all to new versions
                 foreach (var package in existingPackages)
@@ -503,7 +503,7 @@ internal static partial class MSBuildHelper
         var tempDirectory = Directory.CreateTempSubdirectory("package-dependency-coherence_");
         try
         {
-            var tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages);
+            var tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages, logger);
             var (exitCode, stdOut, stdErr) = await ProcessEx.RunAsync("dotnet", ["restore", tempProjectPath], workingDirectory: tempDirectory.FullName);
             ThrowOnUnauthenticatedFeed(stdOut);
 
@@ -627,7 +627,7 @@ internal static partial class MSBuildHelper
         return projectRoot;
     }
 
-    private static IEnumerable<PackageSource>? LoadPackageSources(string nugetConfigPath)
+    private static IEnumerable<PackageSource>? LoadPackageSources(string nugetConfigPath, ILogger logger)
     {
         try
         {
@@ -638,8 +638,8 @@ internal static partial class MSBuildHelper
         }
         catch (NuGetConfigurationException ex)
         {
-            Console.WriteLine("Error while parsing NuGet.config");
-            Console.WriteLine(ex.Message);
+            logger.Warn("Error while parsing NuGet.config");
+            logger.Warn(ex.Message);
 
             // Nuget.config is invalid. Won't be able to do anything with specific sources.
             return null;
@@ -652,6 +652,7 @@ internal static partial class MSBuildHelper
         string projectPath,
         string targetFramework,
         IReadOnlyCollection<Dependency> packages,
+        ILogger logger,
         bool usePackageDownload = false)
     {
         var projectDirectory = Path.GetDirectoryName(projectPath);
@@ -664,7 +665,7 @@ internal static partial class MSBuildHelper
             File.Copy(nugetConfigPath, Path.Combine(tempDir.FullName, "NuGet.Config"));
             var nugetConfigDir = Path.GetDirectoryName(nugetConfigPath);
 
-            var packageSources = LoadPackageSources(nugetConfigPath);
+            var packageSources = LoadPackageSources(nugetConfigPath, logger);
             if (packageSources is not null)
             {
                 // We need to copy local package sources from the NuGet.Config file to the temp directory
@@ -761,7 +762,7 @@ internal static partial class MSBuildHelper
         ThrowOnUnauthenticatedFeed(stdOut);
         if (exitCode != 0)
         {
-            logger.Log($"Error determining target frameworks.\nSTDOUT:\n{stdOut}\nSTDERR:\n{stdErr}");
+            logger.Warn($"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
@@ -805,13 +806,13 @@ internal static partial class MSBuildHelper
         string projectPath,
         string targetFramework,
         IReadOnlyCollection<Dependency> packages,
-        ILogger? logger = null)
+        ILogger logger)
     {
         var tempDirectory = Directory.CreateTempSubdirectory("package-dependency-resolution_");
         try
         {
             var topLevelPackagesNames = packages.Select(p => p.Name).ToHashSet(StringComparer.OrdinalIgnoreCase);
-            var tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages);
+            var tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages, logger);
 
             var (exitCode, stdout, stderr) = await ProcessEx.RunAsync("dotnet", ["build", tempProjectPath, "/t:_ReportDependencies"], workingDirectory: tempDirectory.FullName);
             ThrowOnUnauthenticatedFeed(stdout);
@@ -836,7 +837,7 @@ internal static partial class MSBuildHelper
             }
             else
             {
-                logger?.Log($"dotnet build in {nameof(GetAllPackageDependenciesAsync)} failed. STDOUT: {stdout} STDERR: {stderr}");
+                logger?.Warn($"dotnet build in {nameof(GetAllPackageDependenciesAsync)} failed. STDOUT: {stdout} STDERR: {stderr}");
                 return [];
             }
         }

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

@@ -4,28 +4,12 @@ namespace NuGetUpdater.Core;
 
 internal static class NuGetHelper
 {
-    internal const string PackagesConfigFileName = "packages.config";
-
-    public static bool TryGetPackagesConfigFile(string projectPath, [NotNullWhen(returnValue: true)] out string? packagesConfigPath)
-    {
-        var projectDirectory = Path.GetDirectoryName(projectPath);
-
-        packagesConfigPath = PathHelper.JoinPath(projectDirectory, PackagesConfigFileName);
-        if (File.Exists(packagesConfigPath))
-        {
-            return true;
-        }
-
-        packagesConfigPath = null;
-        return false;
-    }
-
     internal static async Task<bool> DownloadNuGetPackagesAsync(string repoRoot, string projectPath, IReadOnlyCollection<Dependency> packages, ILogger logger)
     {
         var tempDirectory = Directory.CreateTempSubdirectory("msbuild_sdk_restore_");
         try
         {
-            var tempProjectPath = await MSBuildHelper.CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, "netstandard2.0", packages, usePackageDownload: true);
+            var tempProjectPath = await MSBuildHelper.CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, "netstandard2.0", packages, logger, usePackageDownload: true);
             var (exitCode, stdOut, stdErr) = await ProcessEx.RunAsync("dotnet", ["restore", tempProjectPath]);
 
             return exitCode == 0;

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

@@ -105,7 +105,7 @@ internal static class PathHelper
     /// </summary>
     /// <param name="filePath">The file path to resolve.</param>
     /// <param name="repoRootPath">The root path of the repository.</param>
-    public static string? ResolveCaseInsensitivePathInsideRepoRoot(string filePath, string repoRootPath)
+    public static List<string>? ResolveCaseInsensitivePathsInsideRepoRoot(string filePath, string repoRootPath)
     {
         if (string.IsNullOrEmpty(filePath) || string.IsNullOrEmpty(repoRootPath))
         {
@@ -123,7 +123,7 @@ internal static class PathHelper
         }
 
         // Start resolving from the root path
-        var currentPath = normalizedRepoRoot;
+        var currentPaths = new List<string> { normalizedRepoRoot };
         var relativePath = normalizedFilePath.Substring(normalizedRepoRoot.Length).TrimStart('/');
 
         foreach (var part in relativePath.Split('/'))
@@ -133,20 +133,28 @@ internal static class PathHelper
                 continue;
             }
 
-            // Enumerate the current directory to find a case-insensitive match
-            var nextPath = Directory
-                .EnumerateFileSystemEntries(currentPath)
-                .FirstOrDefault(entry => string.Equals(Path.GetFileName(entry), part, StringComparison.OrdinalIgnoreCase));
+            var nextPaths = new List<string>();
 
-            if (nextPath == null)
+            // Iterate through all current paths to find matches for the current part
+            foreach (var currentPath in currentPaths)
+            {
+                var matches = Directory
+                    .EnumerateFileSystemEntries(currentPath)
+                    .Where(entry => string.Equals(Path.GetFileName(entry), part, StringComparison.OrdinalIgnoreCase));
+
+                nextPaths.AddRange(matches);
+            }
+
+            if (!nextPaths.Any())
             {
                 return null; // Part of the path does not exist
             }
 
-            currentPath = nextPath;
+            currentPaths = nextPaths;
         }
 
-        return currentPath.NormalizePathToUnix(); // Fully resolved path with correct casing
+        // Normalize all resulting paths to Unix format
+        return currentPaths.Select(path => path.NormalizePathToUnix()).ToList();
     }
 
     /// <summary>

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

@@ -0,0 +1,96 @@
+using System.Collections.Immutable;
+
+using Microsoft.Build.Construction;
+
+namespace NuGetUpdater.Core.Utilities;
+
+internal static class ProjectHelper
+{
+    public const string PackagesConfigFileName = "packages.config";
+    public const string AppConfigFileName = "app.config";
+    public const string WebConfigFileName = "web.config";
+    public const string PackagesLockJsonFileName = "packages.lock.json";
+
+    public enum PathFormat
+    {
+        Relative,
+        Full,
+    }
+
+    public static ImmutableArray<string> GetAllAdditionalFilesFromProject(string fullProjectPath, PathFormat pathFormat)
+    {
+        return GetAdditionalFilesFromProjectContent(fullProjectPath, pathFormat)
+            .AddRange(GetAdditionalFilesFromProjectLocation(fullProjectPath, pathFormat));
+    }
+
+    public static ImmutableArray<string> GetAdditionalFilesFromProjectContent(string fullProjectPath, PathFormat pathFormat)
+    {
+        var projectRootElement = ProjectRootElement.Open(fullProjectPath);
+        var additionalFilesWithFullPaths = new[]
+        {
+            projectRootElement.GetItemPathWithFileName(PackagesConfigFileName),
+            projectRootElement.GetItemPathWithFileName(AppConfigFileName),
+            projectRootElement.GetItemPathWithFileName(WebConfigFileName),
+        }.Where(p => p is not null).Cast<string>().ToImmutableArray();
+
+        var additionalFiles = additionalFilesWithFullPaths
+            .Select(p => MakePathAppropriateFormat(fullProjectPath, p, pathFormat))
+            .ToImmutableArray();
+        return additionalFiles;
+    }
+
+    public static ImmutableArray<string> GetAdditionalFilesFromProjectLocation(string fullProjectPath, PathFormat pathFormat)
+    {
+        var additionalFilesWithFullPaths = new[]
+        {
+            GetPathWithRegardsToProjectFile(fullProjectPath, PackagesLockJsonFileName),
+        }.Where(p => p is not null).Cast<string>().ToImmutableArray();
+
+        var additionalFiles = additionalFilesWithFullPaths
+            .Select(p => MakePathAppropriateFormat(fullProjectPath, p, pathFormat))
+            .ToImmutableArray();
+        return additionalFiles;
+    }
+
+    public static string? GetPackagesConfigPathFromProject(string fullProjectPath, PathFormat pathFormat)
+    {
+        var additionalFiles = GetAdditionalFilesFromProjectContent(fullProjectPath, pathFormat);
+        var packagesConfigFile = additionalFiles.FirstOrDefault(p => Path.GetFileName(p).Equals(PackagesConfigFileName, StringComparison.Ordinal));
+        return packagesConfigFile;
+    }
+
+    private static string MakePathAppropriateFormat(string fullProjectPath, string fullFilePath, PathFormat pathFormat)
+    {
+        var projectDirectory = Path.GetDirectoryName(fullProjectPath)!;
+        var updatedPath = pathFormat switch
+        {
+            PathFormat.Full => fullFilePath,
+            PathFormat.Relative => Path.GetRelativePath(projectDirectory, fullFilePath),
+            _ => throw new NotSupportedException(),
+        };
+        return updatedPath.NormalizePathToUnix();
+    }
+
+    private static string? GetItemPathWithFileName(this ProjectRootElement projectRootElement, string itemFileName)
+    {
+        var projectDirectory = Path.GetDirectoryName(projectRootElement.FullPath)!;
+        var itemPath = projectRootElement.Items
+            .Where(i => i.ElementName.Equals("None", StringComparison.OrdinalIgnoreCase) ||
+                        i.ElementName.Equals("Content", StringComparison.OrdinalIgnoreCase))
+            .Where(i => Path.GetFileName(i.Include).Equals(itemFileName, StringComparison.OrdinalIgnoreCase))
+            .Select(i => Path.GetFullPath(Path.Combine(projectDirectory, i.Include)))
+            .Where(File.Exists)
+            .FirstOrDefault()
+            ?.NormalizePathToUnix();
+        return itemPath;
+    }
+
+    private static string? GetPathWithRegardsToProjectFile(string fullProjectPath, string fileName)
+    {
+        var projectDirectory = Path.GetDirectoryName(fullProjectPath)!;
+        var filePath = Directory.EnumerateFiles(projectDirectory)
+            .Where(p => Path.GetFileName(p).Equals(fileName, StringComparison.Ordinal))
+            .FirstOrDefault();
+        return filePath;
+    }
+}

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

@@ -19,7 +19,9 @@ public class AnalyzeWorkerTestBase
         DependencyInfo dependencyInfo,
         ExpectedAnalysisResult expectedResult,
         MockNuGetPackage[]? packages = null,
-        TestFile[]? extraFiles = null)
+        TestFile[]? extraFiles = null,
+        ExperimentsManager? experimentsManager = null
+    )
     {
         var relativeDependencyPath = $"./dependabot/dependency/{dependencyInfo.Name}.json";
 
@@ -28,6 +30,7 @@ public class AnalyzeWorkerTestBase
             (relativeDependencyPath, JsonSerializer.Serialize(dependencyInfo, AnalyzeWorker.SerializerOptions)),
         ];
 
+        experimentsManager ??= new ExperimentsManager();
         var allFiles = files.Concat(extraFiles ?? []).ToArray();
         var actualResult = await RunAnalyzerAsync(dependencyInfo.Name, allFiles, async directoryPath =>
         {
@@ -36,7 +39,7 @@ public class AnalyzeWorkerTestBase
             var discoveryPath = Path.GetFullPath(DiscoveryWorker.DiscoveryResultFileName, directoryPath);
             var dependencyPath = Path.GetFullPath(relativeDependencyPath, directoryPath);
 
-            var worker = new AnalyzeWorker(new TestLogger());
+            var worker = new AnalyzeWorker(experimentsManager, new TestLogger());
             var result = await worker.RunWithErrorHandlingAsync(directoryPath, discoveryPath, dependencyPath);
             return result;
         });