dependabot-nuget 0.276.0 → 0.278.0

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

@@ -0,0 +1,283 @@
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+using NuGetUpdater.Core.Analyze;
+using NuGetUpdater.Core.Discover;
+using NuGetUpdater.Core.Run.ApiModel;
+
+namespace NuGetUpdater.Core.Run;
+
+public class RunWorker
+{
+    private readonly IApiHandler _apiHandler;
+    private readonly Logger _logger;
+
+    internal static readonly JsonSerializerOptions SerializerOptions = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.KebabCaseLower,
+        WriteIndented = true,
+        Converters = { new JsonStringEnumConverter() },
+    };
+
+    public RunWorker(IApiHandler apiHandler, Logger logger)
+    {
+        _apiHandler = apiHandler;
+        _logger = logger;
+    }
+
+    public async Task RunAsync(FileInfo jobFilePath, DirectoryInfo repoContentsPath, string baseCommitSha, FileInfo outputFilePath)
+    {
+        var jobFileContent = await File.ReadAllTextAsync(jobFilePath.FullName);
+        var jobWrapper = Deserialize(jobFileContent);
+        var result = await RunAsync(jobWrapper.Job, repoContentsPath, baseCommitSha);
+        var resultJson = JsonSerializer.Serialize(result, SerializerOptions);
+        await File.WriteAllTextAsync(outputFilePath.FullName, resultJson);
+    }
+
+    public async Task<RunResult> RunAsync(Job job, DirectoryInfo repoContentsPath, string baseCommitSha)
+    {
+        MSBuildHelper.RegisterMSBuild(repoContentsPath.FullName, repoContentsPath.FullName);
+
+        var allDependencyFiles = new Dictionary<string, DependencyFile>();
+        foreach (var directory in job.GetAllDirectories())
+        {
+            var result = await RunForDirectory(job, repoContentsPath, directory, baseCommitSha);
+            foreach (var dependencyFile in result.Base64DependencyFiles)
+            {
+                allDependencyFiles[dependencyFile.Name] = dependencyFile;
+            }
+        }
+
+        var runResult = new RunResult()
+        {
+            Base64DependencyFiles = allDependencyFiles.Values.ToArray(),
+            BaseCommitSha = baseCommitSha,
+        };
+        return runResult;
+    }
+
+    private async Task<RunResult> RunForDirectory(Job job, DirectoryInfo repoContentsPath, string repoDirectory, string baseCommitSha)
+    {
+        var discoveryWorker = new DiscoveryWorker(_logger);
+        var discoveryResult = await discoveryWorker.RunAsync(repoContentsPath.FullName, repoDirectory);
+        // TODO: check discoveryResult.ErrorType
+
+        _logger.Log("Discovery JSON content:");
+        _logger.Log(JsonSerializer.Serialize(discoveryResult, DiscoveryWorker.SerializerOptions));
+
+        // report dependencies
+        var discoveredUpdatedDependencies = GetUpdatedDependencyListFromDiscovery(discoveryResult);
+        await _apiHandler.UpdateDependencyList(discoveredUpdatedDependencies);
+
+        // TODO: pull out relevant dependencies, then check each for updates and track the changes
+        // TODO: for each top-level dependency, _or_ specific dependency (if security, use transitive)
+        var originalDependencyFileContents = new Dictionary<string, string>();
+        var allowedUpdates = job.AllowedUpdates ?? [];
+        var actualUpdatedDependencies = new List<ReportedDependency>();
+        if (allowedUpdates.Any(a => a.UpdateType == "all"))
+        {
+            await _apiHandler.IncrementMetric(new()
+            {
+                Metric = "updater.started",
+                Tags = { ["operation"] = "group_update_all_versions" },
+            });
+
+            // track original contents for later handling
+            foreach (var project in discoveryResult.Projects)
+            {
+                // TODO: include global.json, etc.
+                var path = Path.Join(discoveryResult.Path, project.FilePath).NormalizePathToUnix().EnsurePrefix("/");
+                var localPath = Path.Join(repoContentsPath.FullName, discoveryResult.Path, project.FilePath);
+                var content = await File.ReadAllTextAsync(localPath);
+                originalDependencyFileContents[path] = content;
+            }
+
+            // do update
+            _logger.Log($"Running update in directory {repoDirectory}");
+            foreach (var project in discoveryResult.Projects)
+            {
+                foreach (var dependency in project.Dependencies.Where(d => !d.IsTransitive))
+                {
+                    if (dependency.Name == "Microsoft.NET.Sdk")
+                    {
+                        // this can't be updated
+                        // TODO: pull this out of discovery?
+                        continue;
+                    }
+
+                    if (dependency.Version is null)
+                    {
+                        // if we don't know the version, there's nothing we can do
+                        continue;
+                    }
+
+                    var analyzeWorker = new AnalyzeWorker(_logger);
+                    var dependencyInfo = new DependencyInfo()
+                    {
+                        Name = dependency.Name,
+                        Version = dependency.Version!,
+                        IsVulnerable = false,
+                        IgnoredVersions = [],
+                        Vulnerabilities = [],
+                    };
+                    var analysisResult = await analyzeWorker.RunAsync(repoContentsPath.FullName, discoveryResult, dependencyInfo);
+                    // TODO: log analysisResult
+                    // TODO: check analysisResult.ErrorType
+                    if (analysisResult.CanUpdate)
+                    {
+                        // TODO: this is inefficient, but not likely causing a bottleneck
+                        var previousDependency = discoveredUpdatedDependencies.Dependencies
+                            .Single(d => d.Name == dependency.Name && d.Requirements.Single().File == Path.Join(discoveryResult.Path, project.FilePath).NormalizePathToUnix().EnsurePrefix("/"));
+                        var updatedDependency = new ReportedDependency()
+                        {
+                            Name = dependency.Name,
+                            Version = analysisResult.UpdatedVersion,
+                            Requirements =
+                            [
+                                new ReportedRequirement()
+                                {
+                                    File = Path.Join(discoveryResult.Path, project.FilePath).NormalizePathToUnix().EnsurePrefix("/"),
+                                    Requirement = analysisResult.UpdatedVersion,
+                                    Groups = previousDependency.Requirements.Single().Groups,
+                                    Source = new RequirementSource()
+                                    {
+                                        SourceUrl = analysisResult.UpdatedDependencies.Single(d => d.Name == dependency.Name).InfoUrl,
+                                    },
+                                }
+                            ],
+                            PreviousVersion = dependency.Version,
+                            PreviousRequirements = previousDependency.Requirements,
+                        };
+
+                        var updateWorker = new UpdaterWorker(_logger);
+                        var dependencyFilePath = Path.Join(discoveryResult.Path, project.FilePath).NormalizePathToUnix();
+                        var updateResult = await updateWorker.RunAsync(repoContentsPath.FullName, dependencyFilePath, dependency.Name, dependency.Version!, analysisResult.UpdatedVersion, isTransitive: false);
+                        // TODO: check specific contents of result.ErrorType
+                        // TODO: need to report if anything was actually updated
+                        if (updateResult.ErrorType is null || updateResult.ErrorType == ErrorType.None)
+                        {
+                            actualUpdatedDependencies.Add(updatedDependency);
+                        }
+                    }
+                }
+            }
+
+            // create PR - we need to manually check file contents; we can't easily use `git status` in tests
+            var updatedDependencyFiles = new List<DependencyFile>();
+            foreach (var project in discoveryResult.Projects)
+            {
+                var path = Path.Join(discoveryResult.Path, project.FilePath).NormalizePathToUnix().EnsurePrefix("/");
+                var localPath = Path.Join(repoContentsPath.FullName, discoveryResult.Path, project.FilePath);
+                var updatedContent = await File.ReadAllTextAsync(localPath);
+                var originalContent = originalDependencyFileContents[path];
+                if (updatedContent != originalContent)
+                {
+                    updatedDependencyFiles.Add(new DependencyFile()
+                    {
+                        Name = project.FilePath,
+                        Content = updatedContent,
+                        Directory = discoveryResult.Path,
+                    });
+                }
+            }
+
+            if (updatedDependencyFiles.Count > 0)
+            {
+                var createPullRequest = new CreatePullRequest()
+                {
+                    Dependencies = actualUpdatedDependencies.ToArray(),
+                    UpdatedDependencyFiles = updatedDependencyFiles.ToArray(),
+                    BaseCommitSha = baseCommitSha,
+                    CommitMessage = "TODO: message",
+                    PrTitle = "TODO: title",
+                    PrBody = "TODO: body",
+                };
+                await _apiHandler.CreatePullRequest(createPullRequest);
+                // TODO: log updated dependencies to console
+            }
+            else
+            {
+                // TODO: log or throw if nothing was updated, but was expected to be
+            }
+        }
+        else
+        {
+            // TODO: throw if no updates performed
+        }
+
+        await _apiHandler.MarkAsProcessed(new() { BaseCommitSha = baseCommitSha });
+        var result = new RunResult()
+        {
+            Base64DependencyFiles = originalDependencyFileContents.Select(kvp => new DependencyFile()
+            {
+                Name = Path.GetFileName(kvp.Key),
+                Content = Convert.ToBase64String(Encoding.UTF8.GetBytes(kvp.Value)),
+                Directory = Path.GetDirectoryName(kvp.Key)!.NormalizePathToUnix(),
+            }).ToArray(),
+            BaseCommitSha = baseCommitSha,
+        };
+        return result;
+    }
+
+    internal static UpdatedDependencyList GetUpdatedDependencyListFromDiscovery(WorkspaceDiscoveryResult discoveryResult)
+    {
+        string GetFullRepoPath(string path)
+        {
+            // ensures `path\to\file` is `/path/to/file`
+            return Path.Join(discoveryResult.Path, path).NormalizePathToUnix().NormalizeUnixPathParts().EnsurePrefix("/");
+        }
+
+        var auxiliaryFiles = new List<string>();
+        if (discoveryResult.GlobalJson is not null)
+        {
+            auxiliaryFiles.Add(GetFullRepoPath(discoveryResult.GlobalJson.FilePath));
+        }
+        if (discoveryResult.DotNetToolsJson is not null)
+        {
+            auxiliaryFiles.Add(GetFullRepoPath(discoveryResult.DotNetToolsJson.FilePath));
+        }
+        if (discoveryResult.DirectoryPackagesProps is not null)
+        {
+            auxiliaryFiles.Add(GetFullRepoPath(discoveryResult.DirectoryPackagesProps.FilePath));
+        }
+
+        var updatedDependencyList = new UpdatedDependencyList()
+        {
+            Dependencies = discoveryResult.Projects.SelectMany(p =>
+            {
+                return p.Dependencies.Where(d => d.Version is not null).Select(d =>
+                    new ReportedDependency()
+                    {
+                        Name = d.Name,
+                        Requirements = d.IsTransitive ? [] : [new ReportedRequirement()
+                        {
+                            File = GetFullRepoPath(p.FilePath),
+                            Requirement = d.Version!,
+                            Groups = ["dependencies"],
+                        }],
+                        Version = d.Version,
+                    }
+                );
+            }).ToArray(),
+            DependencyFiles = discoveryResult.Projects.Select(p => GetFullRepoPath(p.FilePath)).Concat(auxiliaryFiles).ToArray(),
+        };
+        return updatedDependencyList;
+    }
+
+    public static JobFile Deserialize(string json)
+    {
+        var jobFile = JsonSerializer.Deserialize<JobFile>(json, SerializerOptions);
+        if (jobFile is null)
+        {
+            throw new InvalidOperationException("Unable to deserialize job wrapper.");
+        }
+
+        if (jobFile.Job.PackageManager != "nuget")
+        {
+            throw new InvalidOperationException("Package manager must be 'nuget'");
+        }
+
+        return jobFile;
+    }
+}

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

@@ -0,0 +1,28 @@
+namespace NuGetUpdater.Core;
+
+internal static class LockFileUpdater
+{
+    public static async Task UpdateLockFileAsync(
+        string repoRootPath,
+        string projectPath,
+        Logger logger)
+    {
+        var projectDirectory = Path.GetDirectoryName(projectPath);
+        var lockPath = Path.Combine(projectDirectory, "packages.lock.json");
+        logger.Log($"    Updating lock file");
+        if (!File.Exists(lockPath))
+        {
+            logger.Log($"      File [{Path.GetRelativePath(repoRootPath, lockPath)}] does not exist.");
+            return;
+        }
+
+        await MSBuildHelper.SidelineGlobalJsonAsync(projectDirectory, repoRootPath, async () =>
+        {
+            var (exitCode, stdout, stderr) = await ProcessEx.RunAsync("dotnet", $"restore --force-evaluate {projectPath}", workingDirectory: projectDirectory);
+            if (exitCode != 0)
+            {
+                logger.Log($"      Lock file update failed.\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}");
+            }
+        }, retainMSBuildSdks: true);
+    }
+}

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

@@ -24,6 +24,15 @@ public class UpdaterWorker
     }
 
     public async Task RunAsync(string repoRootPath, string workspacePath, string dependencyName, string previousDependencyVersion, string newDependencyVersion, bool isTransitive, string? resultOutputPath = null)
+    {
+        var result = await RunAsync(repoRootPath, workspacePath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
+        if (resultOutputPath is { })
+        {
+            await WriteResultFile(result, resultOutputPath, _logger);
+        }
+    }
+
+    public async Task<UpdateOperationResult> RunAsync(string repoRootPath, string workspacePath, string dependencyName, string previousDependencyVersion, string newDependencyVersion, bool isTransitive)
     {
         MSBuildHelper.RegisterMSBuild(Environment.CurrentDirectory, repoRootPath);
         UpdateOperationResult result;
@@ -83,10 +92,7 @@ public class UpdaterWorker
         }
 
         _processedProjectPaths.Clear();
-        if (resultOutputPath is { })
-        {
-            await WriteResultFile(result, resultOutputPath, _logger);
-        }
+        return result;
     }
 
     internal static async Task WriteResultFile(UpdateOperationResult result, string resultOutputPath, Logger logger)
@@ -189,5 +195,11 @@ public class UpdaterWorker
 
         // Some repos use a mix of packages.config and PackageReference
         await SdkPackageUpdater.UpdateDependencyAsync(repoRootPath, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive, _logger);
+
+        // Update lock file if exists
+        if (File.Exists(Path.Combine(Path.GetDirectoryName(projectPath), "packages.lock.json")))
+        {
+            await LockFileUpdater.UpdateLockFileAsync(repoRootPath, projectPath, _logger);
+        }
     }
 }

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

@@ -25,8 +25,42 @@ internal static class PathHelper
             : Path.Combine(path1, path2);
     }
 
+    public static string EnsurePrefix(this string s, string prefix) => s.StartsWith(prefix) ? s : prefix + s;
+
     public static string NormalizePathToUnix(this string path) => path.Replace("\\", "/");
 
+    public static string NormalizeUnixPathParts(this string path)
+    {
+        var parts = path.Split('/');
+        var resultantParts = new List<string>();
+        foreach (var part in parts)
+        {
+            switch (part)
+            {
+                case "":
+                case ".":
+                    break;
+                case "..":
+                    if (resultantParts.Count > 0)
+                    {
+                        resultantParts.RemoveAt(resultantParts.Count - 1);
+                    }
+                    break;
+                default:
+                    resultantParts.Add(part);
+                    break;
+            }
+        }
+
+        var result = string.Join("/", resultantParts);
+        if (path.StartsWith("/") && !result.StartsWith("/"))
+        {
+            result = "/" + result;
+        }
+
+        return result;
+    }
+
     public static string GetFullPathFromRelative(string rootPath, string relativePath)
         => Path.GetFullPath(JoinPath(rootPath, relativePath.NormalizePathToUnix()));
 

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

@@ -0,0 +1,223 @@
+using System.Text;
+using System.Text.Json;
+using System.Xml.Linq;
+
+using NuGetUpdater.Core.Run;
+using NuGetUpdater.Core.Run.ApiModel;
+using NuGetUpdater.Core.Test.Update;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Run;
+
+using TestFile = (string Path, string Content);
+
+public class RunWorkerTests
+{
+    [Fact]
+    public async Task UpdateSinglePackageProducedExpectedAPIMessages()
+    {
+        var repoMetadata = XElement.Parse("""<repository type="git" url="https://nuget.example.com/some-package" />""");
+        await RunAsync(
+            packages:
+            [
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "1.0.0", "net8.0", additionalMetadata: [repoMetadata]),
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "1.0.1", "net8.0", additionalMetadata: [repoMetadata]),
+            ],
+            job: new Job()
+            {
+                PackageManager = "nuget",
+                Source = new()
+                {
+                    Provider = "github",
+                    Repo = "test/repo",
+                    Directory = "some-dir",
+                },
+                AllowedUpdates =
+                [
+                    new() { UpdateType = "all" }
+                ]
+            },
+            files:
+            [
+                ("some-dir/project.csproj", """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFramework>net8.0</TargetFramework>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <PackageReference Include="Some.Package" Version="1.0.0" />
+                      </ItemGroup>
+                    </Project>
+                    """)
+            ],
+            expectedResult: new RunResult()
+            {
+                Base64DependencyFiles =
+                [
+                    new DependencyFile()
+                    {
+                        Directory = "/some-dir",
+                        Name = "project.csproj",
+                        Content = Convert.ToBase64String(Encoding.UTF8.GetBytes("""
+                            <Project Sdk="Microsoft.NET.Sdk">
+                              <PropertyGroup>
+                                <TargetFramework>net8.0</TargetFramework>
+                              </PropertyGroup>
+                              <ItemGroup>
+                                <PackageReference Include="Some.Package" Version="1.0.0" />
+                              </ItemGroup>
+                            </Project>
+                            """))
+                    }
+                ],
+                BaseCommitSha = "TEST-COMMIT-SHA",
+            },
+            expectedApiMessages:
+            [
+                new UpdatedDependencyList()
+                {
+                    Dependencies =
+                    [
+                        new ReportedDependency()
+                        {
+                            Name = "Some.Package",
+                            Version = "1.0.0",
+                            Requirements =
+                            [
+                                new ReportedRequirement()
+                                {
+                                    Requirement = "1.0.0",
+                                    File = "/some-dir/project.csproj",
+                                    Groups = ["dependencies"],
+                                }
+                            ]
+                        }
+                    ],
+                    DependencyFiles = ["/some-dir/project.csproj"],
+                },
+                new IncrementMetric()
+                {
+                    Metric = "updater.started",
+                    Tags = new()
+                    {
+                        ["operation"] = "group_update_all_versions"
+                    }
+                },
+                new CreatePullRequest()
+                {
+                    Dependencies =
+                    [
+                        new ReportedDependency()
+                        {
+                            Name = "Some.Package",
+                            Version = "1.0.1",
+                            Requirements =
+                            [
+                                new ReportedRequirement()
+                                {
+                                    Requirement = "1.0.1",
+                                    File = "/some-dir/project.csproj",
+                                    Groups = ["dependencies"],
+                                    Source = new()
+                                    {
+                                        SourceUrl = "https://nuget.example.com/some-package",
+                                        Type = "nuget_repo",
+                                    }
+                                }
+                            ],
+                            PreviousVersion = "1.0.0",
+                            PreviousRequirements =
+                            [
+                                new ReportedRequirement()
+                                {
+                                    Requirement = "1.0.0",
+                                    File = "/some-dir/project.csproj",
+                                    Groups = ["dependencies"],
+                                }
+                            ],
+                        }
+                    ],
+                    UpdatedDependencyFiles =
+                    [
+                        new DependencyFile()
+                        {
+                            Name = "project.csproj",
+                            Directory = "some-dir",
+                            Content = """
+                                <Project Sdk="Microsoft.NET.Sdk">
+                                  <PropertyGroup>
+                                    <TargetFramework>net8.0</TargetFramework>
+                                  </PropertyGroup>
+                                  <ItemGroup>
+                                    <PackageReference Include="Some.Package" Version="1.0.1" />
+                                  </ItemGroup>
+                                </Project>
+                                """,
+                        },
+                    ],
+                    BaseCommitSha = "TEST-COMMIT-SHA",
+                    CommitMessage = "TODO: message",
+                    PrTitle = "TODO: title",
+                    PrBody = "TODO: body",
+                },
+                new MarkAsProcessed()
+                {
+                    BaseCommitSha = "TEST-COMMIT-SHA",
+                }
+            ]
+        );
+    }
+
+    private static async Task RunAsync(Job job, TestFile[] files, RunResult expectedResult, object[] expectedApiMessages, MockNuGetPackage[]? packages = null)
+    {
+        // arrange
+        using var tempDirectory = new TemporaryDirectory();
+        await UpdateWorkerTestBase.MockNuGetPackagesInDirectory(packages, tempDirectory.DirectoryPath);
+        foreach (var (path, content) in files)
+        {
+            var fullPath = Path.Combine(tempDirectory.DirectoryPath, path);
+            var directory = Path.GetDirectoryName(fullPath)!;
+            Directory.CreateDirectory(directory);
+            await File.WriteAllTextAsync(fullPath, content);
+        }
+
+        // act
+        var testApiHandler = new TestApiHandler();
+        var worker = new RunWorker(testApiHandler, new Logger(verbose: false));
+        var repoContentsPath = new DirectoryInfo(tempDirectory.DirectoryPath);
+        var actualResult = await worker.RunAsync(job, repoContentsPath, "TEST-COMMIT-SHA");
+        var actualApiMessages = testApiHandler.ReceivedMessages.ToArray();
+
+        // assert
+        var actualRunResultJson = JsonSerializer.Serialize(actualResult);
+        var expectedRunResultJson = JsonSerializer.Serialize(expectedResult);
+        Assert.Equal(expectedRunResultJson, actualRunResultJson);
+        for (int i = 0; i < Math.Min(actualApiMessages.Length, expectedApiMessages.Length); i++)
+        {
+            var actualMessage = actualApiMessages[i];
+            var expectedMessage = expectedApiMessages[i];
+            Assert.Equal(expectedMessage.GetType(), actualMessage.Type);
+
+            var expectedContent = SerializeObjectAndType(expectedMessage);
+            var actualContent = SerializeObjectAndType(actualMessage.Object);
+            Assert.Equal(expectedContent, actualContent);
+        }
+
+        if (actualApiMessages.Length > expectedApiMessages.Length)
+        {
+            var extraApiMessages = actualApiMessages.Skip(expectedApiMessages.Length).Select(m => SerializeObjectAndType(m.Object)).ToArray();
+            Assert.Fail($"Expected {expectedApiMessages.Length} API messages, but got {extraApiMessages.Length} extra:\n\t{string.Join("\n\t", extraApiMessages)}");
+        }
+        if (expectedApiMessages.Length > actualApiMessages.Length)
+        {
+            var missingApiMessages = expectedApiMessages.Skip(actualApiMessages.Length).Select(m => SerializeObjectAndType(m)).ToArray();
+            Assert.Fail($"Expected {expectedApiMessages.Length} API messages, but only got {actualApiMessages.Length}; missing:\n\t{string.Join("\n\t", missingApiMessages)}");
+        }
+    }
+
+    private static string SerializeObjectAndType(object obj)
+    {
+        return $"{obj.GetType().Name}:{JsonSerializer.Serialize(obj)}";
+    }
+}

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

@@ -0,0 +1,60 @@
+using NuGetUpdater.Core.Run;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Run;
+
+public class SerializationTests
+{
+    [Fact]
+    public void DeserializeJob()
+    {
+        var jobWrapper = RunWorker.Deserialize("""
+            {
+              "job": {
+                "package-manager": "nuget",
+                "allowed-updates": [
+                  {
+                    "update-type": "all"
+                  }
+                ],
+                "debug": false,
+                "dependency-groups": [],
+                "dependencies": null,
+                "dependency-group-to-refresh": null,
+                "existing-pull-requests": [],
+                "existing-group-pull-requests": [],
+                "experiments": null,
+                "ignore-conditions": [],
+                "lockfile-only": false,
+                "requirements-update-strategy": null,
+                "security-advisories": [],
+                "security-updates-only": false,
+                "source": {
+                  "provider": "github",
+                  "repo": "some-org/some-repo",
+                  "directory": "specific-sdk",
+                  "hostname": null,
+                  "api-endpoint": null
+                },
+                "update-subdependencies": false,
+                "updating-a-pull-request": false,
+                "vendor-dependencies": false,
+                "reject-external-code": false,
+                "repo-private": false,
+                "commit-message-options": null,
+                "credentials-metadata": [
+                  {
+                    "host": "github.com",
+                    "type": "git_source"
+                  }
+                ],
+                "max-updater-run-time": 0
+              }
+            }
+            """);
+        Assert.Equal("github", jobWrapper.Job.Source.Provider);
+        Assert.Equal("some-org/some-repo", jobWrapper.Job.Source.Repo);
+        Assert.Equal("specific-sdk", jobWrapper.Job.Source.Directory);
+    }
+}