dependabot-nuget 0.291.0 → 0.292.0

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/RunWorker.cs

@@ -12,6 +12,7 @@ namespace NuGetUpdater.Core.Run;
 
 public class RunWorker
 {
+    private readonly string _jobId;
     private readonly IApiHandler _apiHandler;
     private readonly ILogger _logger;
     private readonly IDiscoveryWorker _discoveryWorker;
@@ -25,8 +26,9 @@ public class RunWorker
         Converters = { new JsonStringEnumConverter(), new RequirementConverter(), new VersionConverter() },
     };
 
-    public RunWorker(IApiHandler apiHandler, IDiscoveryWorker discoverWorker, IAnalyzeWorker analyzeWorker, IUpdaterWorker updateWorker, ILogger logger)
+    public RunWorker(string jobId, IApiHandler apiHandler, IDiscoveryWorker discoverWorker, IAnalyzeWorker analyzeWorker, IUpdaterWorker updateWorker, ILogger logger)
     {
+        _jobId = jobId;
         _apiHandler = apiHandler;
         _logger = logger;
         _discoveryWorker = discoverWorker;
@@ -87,9 +89,13 @@ public class RunWorker
         {
             error = new PrivateSourceAuthenticationFailure(lastUsedPackageSourceUrls);
         }
+        catch (BadRequirementException ex)
+        {
+            error = new BadRequirement(ex.Message);
+        }
         catch (MissingFileException ex)
         {
-            error = new DependencyFileNotFound(ex.FilePath);
+            error = new DependencyFileNotFound("file not found", ex.FilePath);
         }
         catch (UpdateNotPossibleException ex)
         {
@@ -97,7 +103,7 @@ public class RunWorker
         }
         catch (Exception ex)
         {
-            error = new UnknownError(ex.ToString());
+            error = new UnknownError(ex, _jobId);
         }
 
         if (error is not null)

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/LockFileUpdater.cs

@@ -11,7 +11,7 @@ internal static class LockFileUpdater
         var projectDirectory = Path.GetDirectoryName(projectPath)!;
         await MSBuildHelper.HandleGlobalJsonAsync(projectDirectory, repoRootPath, experimentsManager, async () =>
         {
-            var (exitCode, stdout, stderr) = await ProcessEx.RunDotnetWithoutMSBuildEnvironmentVariablesAsync(["restore", "--force-evaluate", projectPath], projectDirectory, experimentsManager);
+            var (exitCode, stdout, stderr) = await ProcessEx.RunDotnetWithoutMSBuildEnvironmentVariablesAsync(["restore", "--force-evaluate", "-p:EnableWindowsTargeting=true", projectPath], projectDirectory, experimentsManager);
             if (exitCode != 0)
             {
                 logger.Error($"      Lock file update failed.\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}");

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/WebApplicationTargetsConditionPatcher.cs

@@ -13,7 +13,18 @@ namespace NuGetUpdater.Core.Updater
                 getContent: () => File.ReadAllText(projectFilePath),
                 setContent: s => File.WriteAllText(projectFilePath, s),
                 nodeFinder: doc => doc.Descendants()
-                    .FirstOrDefault(e => e.Name == "Import" && e.GetAttributeValue("Project") == @"$(VSToolsPath)\WebApplications\Microsoft.WebApplication.targets")
+                    .Where(e => e.Name == "Import")
+                    .FirstOrDefault(e =>
+                    {
+                        var projectPath = e.GetAttributeValue("Project");
+                        if (projectPath is not null)
+                        {
+                            var projectFileName = Path.GetFileName(projectPath.NormalizePathToUnix());
+                            return projectFileName.Equals("Microsoft.WebApplication.targets", StringComparison.OrdinalIgnoreCase);
+                        }
+
+                        return false;
+                    })
                     as XmlNodeSyntax,
                 preProcessor: n =>
                 {

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

@@ -395,7 +395,6 @@ public class PackageManager
                                     if (await AreAllParentsCompatibleAsync(existingPackages, existingPackage, targetFramework, projectDirectory, logger) == true)
                                     {
                                         existingPackage.CurrentVersion = dependencyOldVersion;
-                                        string NewVersion = dependency.CurrentVersion;
                                         existingPackage.NewVersion = dependency.CurrentVersion;
                                         await UpdateVersion(existingPackages, existingPackage, targetFramework, projectDirectory, logger);
                                     }
@@ -593,12 +592,6 @@ public class PackageManager
             return null;
         }
 
-        // If the current version of the parent is less than the current version of the dependency
-        else if (CurrentVersion < currentVersionDependency)
-        {
-            return currentVersionDependency;
-        }
-
         // Loop from the current version to the latest version, use next patch as a limit (unless there's a limit) so it doesn't look for versions that don't exist
         for (NuGetVersion version = CurrentVersion; version <= latestVersion; version = NextPatch(version, versions))
         {

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

@@ -886,6 +886,7 @@ internal static partial class MSBuildHelper
             "The plugin credential provider could not acquire credentials",
             "401 (Unauthorized)",
             "error NU1301: Unable to load the service index for source",
+            "Response status code does not indicate success: 403",
         };
         if (unauthorizedMessageSnippets.Any(stdout.Contains))
         {
@@ -895,9 +896,13 @@ internal static partial class MSBuildHelper
 
     internal static string? GetMissingFile(string output)
     {
-        var missingFilePattern = new Regex(@"The imported project \""(?<FilePath>.*)\"" was not found");
-        var match = missingFilePattern.Match(output);
-        if (match.Success)
+        var missingFilePatterns = new[]
+        {
+            new Regex(@"The imported project \""(?<FilePath>.*)\"" was not found"),
+            new Regex(@"The imported file \""(?<FilePath>.*)\"" does not exist"),
+        };
+        var match = missingFilePatterns.Select(p => p.Match(output)).Where(m => m.Success).FirstOrDefault();
+        if (match is not null)
         {
             return match.Groups["FilePath"].Value;
         }

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

@@ -77,11 +77,11 @@ internal static class ProjectHelper
         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(i => !string.IsNullOrEmpty(i.Include))
+            .Select(i => Path.GetFullPath(Path.Combine(projectDirectory, i.Include.NormalizePathToUnix())))
+            .Where(p => Path.GetFileName(p).Equals(itemFileName, StringComparison.OrdinalIgnoreCase))
             .Where(File.Exists)
-            .FirstOrDefault()
-            ?.NormalizePathToUnix();
+            .FirstOrDefault();
         return itemPath;
     }
 

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Clone/CloneWorkerTests.cs

@@ -95,6 +95,65 @@ public class CloneWorkerTests
         );
     }
 
+    [Fact]
+    public async Task JobFileParseErrorIsReported_InvalidJson()
+    {
+        // arrange
+        var testApiHandler = new TestApiHandler();
+        var testGitCommandHandler = new TestGitCommandHandler();
+        var cloneWorker = new CloneWorker("JOB-ID", testApiHandler, testGitCommandHandler);
+        using var testDirectory = new TemporaryDirectory();
+        var jobFilePath = Path.Combine(testDirectory.DirectoryPath, "job.json");
+        await File.WriteAllTextAsync(jobFilePath, "not json");
+
+        // act
+        var result = await cloneWorker.RunAsync(new FileInfo(jobFilePath), new DirectoryInfo(testDirectory.DirectoryPath));
+
+        // assert
+        Assert.Equal(1, result);
+        var expectedParseErrorObject = testApiHandler.ReceivedMessages.Single(m => m.Type == typeof(UnknownError));
+        var unknownError = (UnknownError)expectedParseErrorObject.Object;
+        Assert.Equal("JsonException", unknownError.Details["error-class"]);
+    }
+
+    [Fact]
+    public async Task JobFileParseErrorIsReported_BadRequirement()
+    {
+        // arrange
+        var testApiHandler = new TestApiHandler();
+        var testGitCommandHandler = new TestGitCommandHandler();
+        var cloneWorker = new CloneWorker("JOB-ID", testApiHandler, testGitCommandHandler);
+        using var testDirectory = new TemporaryDirectory();
+        var jobFilePath = Path.Combine(testDirectory.DirectoryPath, "job.json");
+
+        // write a job file with a valid shape, but invalid requirement
+        await File.WriteAllTextAsync(jobFilePath, """
+            {
+                "job": {
+                    "source": {
+                        "provider": "github",
+                        "repo": "test/repo"
+                    },
+                    "security-advisories": [
+                        {
+                            "dependency-name": "Some.Dependency",
+                            "affected-versions": ["not a valid requirement"]
+                        }
+                    ]
+                }
+            }
+            """);
+
+        // act
+        var result = await cloneWorker.RunAsync(new FileInfo(jobFilePath), new DirectoryInfo(testDirectory.DirectoryPath));
+
+        // assert
+        Assert.Equal(1, result);
+        var expectedParseErrorObject = testApiHandler.ReceivedMessages.Single(m => m.Type == typeof(BadRequirement));
+        var badRequirement = (BadRequirement)expectedParseErrorObject.Object;
+        Assert.Equal("not a valid requirement", badRequirement.Details["message"]);
+    }
+
     private class TestGitCommandHandlerWithOutputs : TestGitCommandHandler
     {
         private readonly string _stdout;
@@ -134,8 +193,7 @@ public class CloneWorkerTests
         // arrange
         var testApiHandler = new TestApiHandler();
         testGitCommandHandler ??= new TestGitCommandHandler();
-        var testLogger = new TestLogger();
-        var worker = new CloneWorker(testApiHandler, testGitCommandHandler, testLogger);
+        var worker = new CloneWorker("TEST-JOB-ID", testApiHandler, testGitCommandHandler);
 
         // act
         var job = new Job()

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

@@ -45,7 +45,16 @@ public class DiscoveryWorkerTestBase : TestBase
         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);
+        if (expectedResult.ErrorDetailsPattern is not null)
+        {
+            var errorDetails = actualResult.ErrorDetails?.ToString();
+            Assert.NotNull(errorDetails);
+            Assert.Matches(expectedResult.ErrorDetailsPattern, errorDetails);
+        }
+        else
+        {
+            Assert.Equal(expectedResult.ErrorDetails, actualResult.ErrorDetails);
+        }
 
         return;
 

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

@@ -115,5 +115,61 @@ public partial class DiscoveryWorkerTests
                 }
             );
         }
+
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public async Task DiscoveryIsMergedWithPackageReferences(bool useDirectDiscovery)
+        {
+            await TestDiscoveryAsync(
+                experimentsManager: new ExperimentsManager() { UseDirectDiscovery = useDirectDiscovery },
+                packages:
+                [
+                    MockNuGetPackage.CreateSimplePackage("Package.A", "1.0.0", "net46"),
+                    MockNuGetPackage.CreateSimplePackage("Package.B", "2.0.0", "net46"),
+                ],
+                workspacePath: "src",
+                files: [
+                    ("src/myproj.csproj", """
+                        <Project Sdk="Microsoft.NET.Sdk">
+                          <PropertyGroup>
+                            <TargetFramework>net46</TargetFramework>
+                          </PropertyGroup>
+                          <ItemGroup>
+                            <None Include="..\unexpected-directory\packages.config" />
+                            <PackageReference Include="Package.B" Version="2.0.0" />
+                          </ItemGroup>
+                        </Project>
+                        """),
+                    ("unexpected-directory/packages.config", """
+                        <?xml version="1.0" encoding="utf-8"?>
+                        <packages>
+                          <package id="Package.A" version="1.0.0" targetFramework="net46" />
+                        </packages>
+                        """),
+                ],
+                expectedResult: new()
+                {
+                    Path = "src",
+                    Projects = [
+                        new()
+                        {
+                            FilePath = "myproj.csproj",
+                            Properties = [new("TargetFramework", "net46", "src/myproj.csproj")],
+                            TargetFrameworks = ["net46"],
+                            Dependencies = [
+                                new("Package.A", "1.0.0", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("Package.B", "2.0.0", DependencyType.PackageReference, IsDirect: true, TargetFrameworks: ["net46"]),
+                            ],
+                            ReferencedProjectPaths = [],
+                            ImportedFiles = [],
+                            AdditionalFiles = [
+                                "../unexpected-directory/packages.config"
+                            ],
+                        }
+                    ],
+                }
+            );
+        }
     }
 }

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

@@ -12,6 +12,7 @@ public record ExpectedWorkspaceDiscoveryResult : NativeResult
     public int? ExpectedProjectCount { get; init; }
     public ExpectedDependencyDiscoveryResult? GlobalJson { get; init; }
     public ExpectedDependencyDiscoveryResult? DotNetToolsJson { get; init; }
+    public string? ErrorDetailsPattern { get; init; } = null;
 }
 
 public record ExpectedSdkProjectDiscoveryResult : ExpectedDependencyDiscoveryResult

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Run/RunWorkerTests.cs

@@ -1733,7 +1733,7 @@ public class RunWorkerTests
         analyzeWorker ??= new AnalyzeWorker(experimentsManager, logger);
         updaterWorker ??= new UpdaterWorker(experimentsManager, logger);
 
-        var worker = new RunWorker(testApiHandler, discoveryWorker, analyzeWorker, updaterWorker, logger);
+        var worker = new RunWorker("TEST-JOB-ID", testApiHandler, discoveryWorker, analyzeWorker, updaterWorker, logger);
         var repoContentsPathDirectoryInfo = new DirectoryInfo(tempDirectory.DirectoryPath);
         var actualResult = await worker.RunAsync(job, repoContentsPathDirectoryInfo, "TEST-COMMIT-SHA");
         var actualApiMessages = testApiHandler.ReceivedMessages.ToArray();

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Run/SerializationTests.cs

@@ -1,6 +1,5 @@
 using NuGet.Versioning;
 
-using NuGetUpdater.Core.Analyze;
 using NuGetUpdater.Core.Run;
 using NuGetUpdater.Core.Run.ApiModel;
 using NuGetUpdater.Core.Test.Utilities;
@@ -228,37 +227,33 @@ public class SerializationTests
         Assert.False(experimentsManager.UseDirectDiscovery);
     }
 
-    [Fact]
-    public async Task DeserializeExperimentsManager_UnsupportedJobFileShape_InfoIsReportedAndEmptyExperimentSetIsReturned()
+    [Theory]
+    [MemberData(nameof(DeserializeErrorTypesData))]
+    public void SerializeError(JobErrorBase error, string expectedSerialization)
     {
-        // arrange
-        using var tempDir = new TemporaryDirectory();
-        var jobFilePath = Path.Combine(tempDir.DirectoryPath, "job.json");
-        var jobContent = """
-            {
-              "this-is-not-a-job-and-parsing-will-fail-but-an-empty-experiment-set-should-sill-be-returned": {
-              }
-            }
-            """;
-        await File.WriteAllTextAsync(jobFilePath, jobContent);
-        var capturingTestLogger = new CapturingTestLogger();
-
-        // act - this is the entrypoint the update command uses to parse the job file
-        var experimentsManager = await ExperimentsManager.FromJobFileAsync(jobFilePath, capturingTestLogger);
+        if (error is UnknownError unknown)
+        {
+            // special case the exception's call stack to make it testable
+            unknown.Details["error-backtrace"] = "TEST-BACKTRACE";
+        }
 
-        // assert
-        Assert.False(experimentsManager.UseLegacyDependencySolver);
-        Assert.False(experimentsManager.UseDirectDiscovery);
-        Assert.Single(capturingTestLogger.Messages, m => m.Contains("Error deserializing job file"));
+        var actual = HttpApiHandler.Serialize(error);
+        Assert.Equal(expectedSerialization, actual);
     }
 
     [Fact]
-    public void SerializeError()
+    public void SerializeError_AllErrorTypesHaveSerializationTests()
     {
-        var error = new JobRepoNotFound("some message");
-        var actual = HttpApiHandler.Serialize(error);
-        var expected = """{"data":{"error-type":"job_repo_not_found","error-details":{"message":"some message"}}}""";
-        Assert.Equal(expected, actual);
+        var untestedTypes = typeof(JobErrorBase).Assembly.GetTypes()
+            .Where(t => t.IsSubclassOf(typeof(JobErrorBase)))
+            .ToHashSet();
+        foreach (object?[] data in DeserializeErrorTypesData())
+        {
+            var testedErrorType = data[0]!.GetType();
+            untestedTypes.Remove(testedErrorType);
+        }
+
+        Assert.Empty(untestedTypes.Select(t => t.Name));
     }
 
     [Fact]
@@ -503,7 +498,9 @@ public class SerializationTests
                         "repo": "some/repo"
                     },
                     "commit-message-options": {
-                        "prefix": "[SECURITY] "
+                        "prefix": "[SECURITY] ",
+                        "prefix-development": null,
+                        "include-scope": true
                     }
                 }
             }
@@ -511,7 +508,58 @@ public class SerializationTests
         var jobWrapper = RunWorker.Deserialize(jsonWrapperJson)!;
         Assert.Equal("[SECURITY] ", jobWrapper.Job.CommitMessageOptions!.Prefix);
         Assert.Null(jobWrapper.Job.CommitMessageOptions!.PrefixDevelopment);
-        Assert.Null(jobWrapper.Job.CommitMessageOptions!.IncludeScope);
+        Assert.True(jobWrapper.Job.CommitMessageOptions!.IncludeScope);
+    }
+
+    public static IEnumerable<object?[]> DeserializeErrorTypesData()
+    {
+        yield return
+        [
+            new BadRequirement("some message"),
+            """
+            {"data":{"error-type":"illformed_requirement","error-details":{"message":"some message"}}}
+            """
+        ];
+
+        yield return
+        [
+            new DependencyFileNotFound("some message", "/some/file"),
+            """
+            {"data":{"error-type":"dependency_file_not_found","error-details":{"message":"some message","file-path":"/some/file"}}}
+            """
+        ];
+
+        yield return
+        [
+            new JobRepoNotFound("some message"),
+            """
+            {"data":{"error-type":"job_repo_not_found","error-details":{"message":"some message"}}}
+            """
+        ];
+
+        yield return
+        [
+            new PrivateSourceAuthenticationFailure(["url1", "url2"]),
+            """
+            {"data":{"error-type":"private_source_authentication_failure","error-details":{"source":"(url1|url2)"}}}
+            """
+        ];
+
+        yield return
+        [
+            new UnknownError(new Exception("some message"), "JOB-ID"),
+            """
+            {"data":{"error-type":"unknown_error","error-details":{"error-class":"Exception","error-message":"some message","error-backtrace":"TEST-BACKTRACE","package-manager":"nuget","job-id":"JOB-ID"}}}
+            """
+        ];
+
+        yield return
+        [
+            new UpdateNotPossible(["dep1", "dep2"]),
+            """
+            {"data":{"error-type":"update_not_possible","error-details":{"dependencies":["dep1","dep2"]}}}
+            """
+        ];
     }
 
     public static IEnumerable<object?[]> DeserializeAllowedUpdatesData()
@@ -596,16 +644,4 @@ public class SerializationTests
             }
         ];
     }
-
-    private class CapturingTestLogger : ILogger
-    {
-        private readonly List<string> _messages = new();
-
-        public IReadOnlyList<string> Messages => _messages;
-
-        public void LogRaw(string message)
-        {
-            _messages.Add(message);
-        }
-    }
 }

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

@@ -47,7 +47,7 @@ public abstract class UpdateWorkerTestBase : TestBase
     {
         return useSolution
             ? TestUpdateForSolution(dependencyName, oldVersion, newVersion, projectFiles: [(projectFilePath, projectContents)], projectFilesExpected: [(projectFilePath, expectedProjectContents)], isTransitive, additionalFiles, additionalFilesExpected, packages, experimentsManager)
-            : TestUpdateForProject(dependencyName, oldVersion, newVersion, projectFile: (projectFilePath, projectContents), expectedProjectContents, isTransitive, additionalFiles, additionalFilesExpected, packages, experimentsManager);
+            : TestUpdateForProject(dependencyName, oldVersion, newVersion, projectFile: (projectFilePath, projectContents), expectedProjectContents, isTransitive, additionalFiles, additionalFilesExpected, additionalChecks: null, packages: packages, experimentsManager: experimentsManager);
     }
 
     protected static Task TestUpdate(
@@ -65,7 +65,7 @@ public abstract class UpdateWorkerTestBase : TestBase
     {
         return useSolution
             ? TestUpdateForSolution(dependencyName, oldVersion, newVersion, projectFiles: [projectFile], projectFilesExpected: [(projectFile.Path, expectedProjectContents)], isTransitive, additionalFiles, additionalFilesExpected, packages, experimentsManager)
-            : TestUpdateForProject(dependencyName, oldVersion, newVersion, projectFile, expectedProjectContents, isTransitive, additionalFiles, additionalFilesExpected, packages, experimentsManager);
+            : TestUpdateForProject(dependencyName, oldVersion, newVersion, projectFile, expectedProjectContents, isTransitive, additionalFiles, additionalFilesExpected, additionalChecks: null, packages: packages, experimentsManager: experimentsManager);
     }
 
     protected static Task TestNoChangeforProject(
@@ -101,6 +101,7 @@ public abstract class UpdateWorkerTestBase : TestBase
         bool isTransitive = false,
         TestFile[]? additionalFiles = null,
         TestFile[]? additionalFilesExpected = null,
+        Action<string>? additionalChecks = null,
         MockNuGetPackage[]? packages = null,
         ExperimentsManager? experimentsManager = null,
         string projectFilePath = "test-project.csproj",
@@ -114,6 +115,7 @@ public abstract class UpdateWorkerTestBase : TestBase
             isTransitive,
             additionalFiles,
             additionalFilesExpected,
+            additionalChecks,
             packages,
             experimentsManager,
             expectedResult);
@@ -127,6 +129,7 @@ public abstract class UpdateWorkerTestBase : TestBase
         bool isTransitive = false,
         TestFile[]? additionalFiles = null,
         TestFile[]? additionalFilesExpected = null,
+        Action<string>? additionalChecks = null,
         MockNuGetPackage[]? packages = null,
         ExperimentsManager? experimentsManager = null,
         ExpectedUpdateOperationResult? expectedResult = null)
@@ -156,6 +159,21 @@ public abstract class UpdateWorkerTestBase : TestBase
             {
                 ValidateUpdateOperationResult(expectedResult, actualResult!);
             }
+            else if ((actualResult.ErrorType ?? ErrorType.None) != ErrorType.None)
+            {
+                throw new Exception($"Result indicates failure: ErrorType={actualResult.ErrorType}, ErrorDetails={actualResult.ErrorDetails}");
+            }
+
+            if (additionalChecks is not null)
+            {
+                var sourcesDirectory = temporaryDirectory;
+                if (placeFilesInSrc)
+                {
+                    sourcesDirectory = Path.Combine(temporaryDirectory, "src");
+                }
+
+                additionalChecks(sourcesDirectory);
+            }
         });
 
         var expectedResultFiles = additionalFilesExpected.Prepend((projectFilePath, expectedProjectContents)).ToArray();

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

@@ -69,10 +69,10 @@ public partial class UpdateWorkerTests
                       <PropertyGroup>
                         <TargetFramework>netstandard2.0</TargetFramework>
                       </PropertyGroup>
-                
+
                       <ItemGroup>
                         <PackageReference Include="Some.Package" Version="13.0.3" />
-                      </ItemGroup>>
+                      </ItemGroup>
                     </Project>
                     """,
                 additionalFiles: