dependabot-nuget 0.292.0 → 0.293.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc0cf2e8a7f769337787f983af710cd8a4c30c464b1118f22589c522b3ed107a
-  data.tar.gz: b1e2fb7957b3cd3daf6331e199ebce5b0f94d84f42033de6e6f0e39bef4295b8
+  metadata.gz: 833b170b34a1cef53346970cdfc208b39f49899aaeeb1d2da285463eabf2aea3
+  data.tar.gz: aea74663e1ec787d2496c6d63f97c531d6ccd5415cdd810ce7d8518080b027cc
 SHA512:
-  metadata.gz: 2c66ad9bb9ce3d932d0965f18fc4a6dde14ae022413343689a7c92f1e9439cca523447c20719f579bbc6c5fe6caeadab1dde0056f0a99e4a1afd09c7a5a79266
-  data.tar.gz: eb4601daef366ea15b011fb20a3efce1b976da73a4c4ba14c991a1aa9910a01d220b2cc46a086e47e7336432597b01f431d65ad4d40b431b1545996e1af613dd
+  metadata.gz: 889ab157302c7dbb0be345ca4e5204fe5518d6aafbd61d7992008404fa84200240e6f88655027ddb4a77611964cb97e2ea7857ad6453d33e498e4d6416b79eb8
+  data.tar.gz: 17f3003ef471825cf980d00da41c528bb051dc64285d6ca808ca84bea09a89b91a197a388d8f62c4e089427a52e77ba24d13b452ec9bc7231b46d18c9c84d697

data/helpers/lib/NuGetUpdater/.gitignore

@@ -4,4 +4,5 @@ bin/
 obj/
 Properties/launchSettings.json
 NuGetUpdater.sln.DotSettings.user
+NuGetUpdater.Core/dotnet-package-correlation.json
 *.binlog

data/helpers/lib/NuGetUpdater/Directory.Packages.props

@@ -26,6 +26,7 @@
     <PackageVersion Include="MSBuild.StructuredLogger" Version="2.2.386" />
     <PackageVersion Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageVersion Include="NuGet.Core" Version="2.14.0" Aliases="CoreV2" />
+    <PackageVersion Include="Semver" Version="3.0.0" />
     <PackageVersion Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
     <PackageVersion Include="System.ComponentModel.Composition" Version="9.0.0" />
     <PackageVersion Include="System.Net.Http" Version="4.3.4" />

data/helpers/lib/NuGetUpdater/DotNetPackageCorrelation/Correlator.cs

@@ -0,0 +1,197 @@
+using System.Collections.Immutable;
+using System.Text.Json;
+using System.Text.RegularExpressions;
+
+using Semver;
+
+namespace DotNetPackageCorrelation;
+
+public partial class Correlator
+{
+    public static readonly JsonSerializerOptions SerializerOptions = new()
+    {
+        WriteIndented = true,
+        Converters = { new SemVersionConverter() },
+    };
+
+    private readonly DirectoryInfo _releaseNotesDirectory;
+
+    public Correlator(DirectoryInfo releaseNotesDirectory)
+    {
+        _releaseNotesDirectory = releaseNotesDirectory;
+    }
+
+    public async Task<(RuntimePackages RuntimePackages, IEnumerable<string> Warnings)> RunAsync()
+    {
+        var runtimeVersions = new List<Version>();
+        foreach (var directory in Directory.EnumerateDirectories(_releaseNotesDirectory.FullName))
+        {
+            var directoryName = Path.GetFileName(directory);
+            if (Version.TryParse(directoryName, out var version))
+            {
+                runtimeVersions.Add(version);
+            }
+        }
+
+        var runtimePackages = new RuntimePackages();
+        var warnings = new List<string>();
+        foreach (var majorVersion in runtimeVersions)
+        {
+            var releasesJsonPath = Path.Combine(_releaseNotesDirectory.FullName, majorVersion.ToString(), "releases.json");
+            if (!File.Exists(releasesJsonPath))
+            {
+                warnings.Add($"Unable to find releases.json file for version {majorVersion}");
+                continue;
+            }
+
+            var releasesJson = await File.ReadAllTextAsync(releasesJsonPath);
+            var releasesFile = JsonSerializer.Deserialize<ReleasesFile>(releasesJson, SerializerOptions)!;
+
+            foreach (var release in releasesFile.Releases)
+            {
+                foreach (var sdk in release.GetSdks())
+                {
+                    if (sdk.Version is null)
+                    {
+                        warnings.Add($"Skipping release with missing version information from {releasesJson}");
+                        continue;
+                    }
+
+                    if (sdk.RuntimeVersion is null)
+                    {
+                        warnings.Add($"Skipping release with missing runtime version information from {releasesJson}");
+                        continue;
+                    }
+
+                    if (runtimePackages.Runtimes.ContainsKey(sdk.RuntimeVersion))
+                    {
+                        // already processed this runtime
+                        continue;
+                    }
+
+                    var packagesAndVersions = new PackageSet();
+                    runtimePackages.Runtimes.Add(sdk.RuntimeVersion, packagesAndVersions);
+                    var runtimeDirectory = new DirectoryInfo(Path.Combine(_releaseNotesDirectory.FullName, majorVersion.ToString(), sdk.RuntimeVersion.ToString()));
+                    var runtimeMarkdownPath = Path.Combine(runtimeDirectory.FullName, $"{sdk.RuntimeVersion}.md");
+                    if (!File.Exists(runtimeMarkdownPath))
+                    {
+                        warnings.Add($"Unable to find expected markdown file {runtimeMarkdownPath}");
+                        continue;
+                    }
+
+                    var markdownContent = await File.ReadAllTextAsync(runtimeMarkdownPath);
+                    var packages = GetPackagesFromMarkdown(runtimeMarkdownPath, markdownContent, warnings);
+                    foreach (var (packageName, packageVersion) in packages)
+                    {
+                        packagesAndVersions.Packages[packageName] = packageVersion;
+                    }
+                }
+            }
+        }
+
+        return (runtimePackages, warnings);
+    }
+
+    public static ImmutableArray<(string Name, SemVersion Version)> GetPackagesFromMarkdown(string markdownPath, string markdownContent, List<string> warnings)
+    {
+        var lines = markdownContent.Split("\n").Select(l => l.Trim()).ToArray();
+
+        // the markdown file contains a table that looks like this:
+        //   Package name | Version
+        //   :----------- | :------------------
+        //   Some.Package | 1.2.3
+        //   ...
+        // however there are some formatting issues with some elements that prevent markdown parsers from
+        // discovering it, so we fall back to manual parsing
+
+        var tableStartLine = -1;
+        for (int i = 0; i < lines.Length; i++)
+        {
+            if (Regex.IsMatch(lines[i], "Package name.*Version"))
+            {
+                tableStartLine = i;
+                break;
+            }
+        }
+
+        if (tableStartLine == -1)
+        {
+            warnings.Add($"Unable to find table start in file {markdownPath}");
+            return [];
+        }
+
+        // skip the column names and separator line
+        tableStartLine += 2;
+
+        var tableEndLine = lines.Length; // assume the end of the file unless we find a blank line
+        for (int i = tableStartLine; i < lines.Length; i++)
+        {
+            if (string.IsNullOrEmpty(lines[i]))
+            {
+                tableEndLine = i;
+                break;
+            }
+        }
+
+        var packages = new List<(string Name, SemVersion Version)>();
+        for (int i = tableStartLine; i < tableEndLine; i++)
+        {
+            var line = lines[i].Trim();
+            var foundMatch = false;
+            foreach (var pattern in SpecialCasePatterns)
+            {
+                var match = pattern.Match(line);
+                if (match.Success)
+                {
+                    var packageName = match.Groups["PackageName"].Value;
+                    var packageVersionString = match.Groups["PackageVersion"].Value;
+                    if (SemVersion.TryParse(packageVersionString, out var packageVersion))
+                    {
+                        packages.Add((packageName, packageVersion));
+                        foundMatch = true;
+                        break; ;
+                    }
+                }
+            }
+
+            if (!foundMatch)
+            {
+                warnings.Add($"Unable to parse package and version from string [{line}] in file [{markdownPath}]:{i}");
+            }
+        }
+
+        return packages.ToImmutableArray();
+    }
+
+    // The different patterns the lines in the markdown might take.  Due to issues with regular expressions, this list
+    // is in a very specific order.
+    private static ImmutableArray<Regex> SpecialCasePatterns { get; } = [
+        StandardLineWithFileExtensions(),
+        StandardLine(),
+        PackageNameDotVersion(),
+        PackageFileNameWithOptionalTrailingPipe(),
+        MultiColumnWithOptionalFileSuffix(),
+    ];
+
+    [GeneratedRegex(@"^(?<PackageName>[^|\s]+)\s*\|\s*(?<PackageVersion>[^|\s]+?)(\.symbols)?\.nupkg$", RegexOptions.Compiled)]
+    // Some.Package | 1.2.3.nupkg
+    // Some.Package | 1.2.3.symbols.nupkg
+    private static partial Regex StandardLineWithFileExtensions();
+
+    [GeneratedRegex(@"^(?<PackageName>[^|\s]+)\s*\|\s*(?<PackageVersion>[^|\s]+)$", RegexOptions.Compiled)]
+    // Some.Package | 1.2.3
+    private static partial Regex StandardLine();
+
+    [GeneratedRegex(@"^(?<PackageName>[^\d]+)\.(?<PackageVersion>[\d].+)$", RegexOptions.Compiled)]
+    // Some.Package.1.2.3
+    private static partial Regex PackageNameDotVersion();
+
+    [GeneratedRegex(@"^(?<PackageName>[^\d]+)\.(?<PackageVersion>\d.+?)\.nupkg(\s+\|)?$", RegexOptions.Compiled)]
+    // some.package.1.2.3.nupkg
+    // some.package.1.2.3.nupkg |
+    private static partial Regex PackageFileNameWithOptionalTrailingPipe();
+
+    [GeneratedRegex(@"^(?<PackageName>[^|\s]+)\s*\|[^|]*\|\s*(?<PackageVersion>.*?)(\.nupkg)?$", RegexOptions.Compiled)]
+    // Some.Package | 1.2 | 1.2.3.nupkg
+    private static partial Regex MultiColumnWithOptionalFileSuffix();
+}

data/helpers/lib/NuGetUpdater/DotNetPackageCorrelation/DotNetPackageCorrelation.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>$(CommonTargetFramework)</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Semver" />
+    <PackageReference Include="System.Text.Json" />
+  </ItemGroup>
+
+</Project>

data/helpers/lib/NuGetUpdater/DotNetPackageCorrelation/Model/PackageMapper.cs

@@ -0,0 +1,68 @@
+using Semver;
+
+namespace DotNetPackageCorrelation;
+
+public class PackageMapper
+{
+    public RuntimePackages RuntimePackages { get; }
+
+    private PackageMapper(RuntimePackages runtimePackages)
+    {
+        RuntimePackages = runtimePackages;
+    }
+
+    /// <summary>
+    /// Find the version of <paramref name="candidatePackageName"/> that shipped at the same time as
+    /// &quot;<paramref name="packageName"/>/<paramref name="packageVersion"/>&quot;.
+    /// </summary>
+    public SemVersion? GetPackageVersionThatShippedWithOtherPackage(string packageName, SemVersion packageVersion, string candidatePackageName)
+    {
+        var runtimeVersion = GetRuntimeVersionFromPackage(packageName, packageVersion);
+        if (runtimeVersion is null)
+        {
+            // no runtime found that contains the package
+            return null;
+        }
+
+        var candidateRuntimeVersions = RuntimePackages.Runtimes.Keys
+            .Where(v => v.Major == runtimeVersion.Major)
+            .Where(v => v.ComparePrecedenceTo(runtimeVersion) <= 0)
+            .OrderBy(v => v, SemVerComparer.Instance)
+            .Reverse()
+            .ToArray();
+        foreach (var candidateRuntimeVersion in candidateRuntimeVersions)
+        {
+            if (!RuntimePackages.Runtimes.TryGetValue(candidateRuntimeVersion, out var packageSet))
+            {
+                continue;
+            }
+
+            if (packageSet.Packages.TryGetValue(candidatePackageName, out var foundPackageVersion))
+            {
+                return foundPackageVersion;
+            }
+        }
+
+        return null;
+    }
+
+    private SemVersion? GetRuntimeVersionFromPackage(string packageName, SemVersion packageVersion)
+    {
+        // TODO: linear search is slow
+        foreach (var runtime in RuntimePackages.Runtimes)
+        {
+            if (runtime.Value.Packages.TryGetValue(packageName, out var foundPackageVersion) &&
+                foundPackageVersion == packageVersion)
+            {
+                return runtime.Key;
+            }
+        }
+
+        return null;
+    }
+
+    public static PackageMapper Load(RuntimePackages runtimePackages)
+    {
+        return new PackageMapper(runtimePackages);
+    }
+}

data/helpers/lib/NuGetUpdater/DotNetPackageCorrelation/Model/PackageSet.cs

@@ -0,0 +1,11 @@
+using System.Text.Json.Serialization;
+
+using Semver;
+
+namespace DotNetPackageCorrelation;
+
+public record PackageSet
+{
+    [JsonObjectCreationHandling(JsonObjectCreationHandling.Populate)]
+    public SortedDictionary<string, SemVersion> Packages { get; init; } = new(StringComparer.OrdinalIgnoreCase);
+}

data/helpers/lib/NuGetUpdater/DotNetPackageCorrelation/Model/Release.cs

@@ -0,0 +1,25 @@
+using System.Collections.Immutable;
+using System.Text.Json.Serialization;
+
+namespace DotNetPackageCorrelation;
+
+public record Release
+{
+    [JsonPropertyName("sdk")]
+    public required Sdk Sdk { get; init; }
+
+    [JsonPropertyName("sdks")]
+    public ImmutableArray<Sdk>? Sdks { get; init; } = [];
+}
+
+public static class ReleaseExtensions
+{
+    public static IEnumerable<Sdk> GetSdks(this Release release)
+    {
+        yield return release.Sdk;
+        foreach (var sdk in release.Sdks ?? [])
+        {
+            yield return sdk;
+        }
+    }
+}

data/helpers/lib/NuGetUpdater/DotNetPackageCorrelation/Model/ReleasesFile.cs

@@ -0,0 +1,9 @@
+using System.Text.Json.Serialization;
+
+namespace DotNetPackageCorrelation;
+
+public record ReleasesFile
+{
+    [JsonPropertyName("releases")]
+    public required Release[] Releases { get; init; }
+}

data/helpers/lib/NuGetUpdater/DotNetPackageCorrelation/Model/RuntimePackages.cs

@@ -0,0 +1,11 @@
+using System.Text.Json.Serialization;
+
+using Semver;
+
+namespace DotNetPackageCorrelation;
+
+public record RuntimePackages
+{
+    [JsonObjectCreationHandling(JsonObjectCreationHandling.Populate)]
+    public SortedDictionary<SemVersion, PackageSet> Runtimes { get; init; } = new(SemVerComparer.Instance);
+}

data/helpers/lib/NuGetUpdater/DotNetPackageCorrelation/Model/Sdk.cs

@@ -0,0 +1,13 @@
+using System.Text.Json.Serialization;
+
+using Semver;
+
+namespace DotNetPackageCorrelation;
+
+public record Sdk
+{
+    [JsonPropertyName("version")]
+    public required SemVersion? Version { get; init; }
+    [JsonPropertyName("runtime-version")]
+    public SemVersion? RuntimeVersion { get; init; }
+}

data/helpers/lib/NuGetUpdater/DotNetPackageCorrelation/Model/SemVerComparer.cs

@@ -0,0 +1,16 @@
+using Semver;
+
+namespace DotNetPackageCorrelation;
+
+public class SemVerComparer : IComparer<SemVersion>
+{
+    public static SemVerComparer Instance = new();
+
+    public int Compare(SemVersion? x, SemVersion? y)
+    {
+        ArgumentNullException.ThrowIfNull(x);
+        ArgumentNullException.ThrowIfNull(y);
+
+        return x.ComparePrecedenceTo(y);
+    }
+}

data/helpers/lib/NuGetUpdater/DotNetPackageCorrelation/Model/SemVersionConverter.cs

@@ -0,0 +1,42 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+using Semver;
+
+namespace DotNetPackageCorrelation;
+
+public class SemVersionConverter : JsonConverter<SemVersion?>
+{
+    public override SemVersion? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        var value = reader.GetString();
+        if (SemVersion.TryParse(value, out var result))
+        {
+            return result;
+        }
+
+        return null;
+    }
+
+    public override SemVersion ReadAsPropertyName(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        var value = Read(ref reader, typeToConvert, options);
+        if (value is null)
+        {
+            throw new JsonException($"Unable to read {nameof(SemVersion)} as property name.");
+        }
+
+        return value;
+    }
+
+    public override void Write(Utf8JsonWriter writer, SemVersion? value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value?.ToString());
+    }
+
+    public override void WriteAsPropertyName(Utf8JsonWriter writer, [DisallowNull] SemVersion value, JsonSerializerOptions options)
+    {
+        writer.WritePropertyName(value.ToString());
+    }
+}

data/helpers/lib/NuGetUpdater/DotNetPackageCorrelation.Cli/DotNetPackageCorrelation.Cli.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>$(CommonTargetFramework)</TargetFramework>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="System.CommandLine" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DotNetPackageCorrelation\DotNetPackageCorrelation.csproj" />
+  </ItemGroup>
+
+</Project>

data/helpers/lib/NuGetUpdater/DotNetPackageCorrelation.Cli/Program.cs

@@ -0,0 +1,32 @@
+using System.CommandLine;
+using System.Text.Json;
+
+using DotNetPackageCorrelation;
+
+namespace DotNetPackageCorrelation.Cli;
+
+public class Program
+{
+    public static async Task<int> Main(string[] args)
+    {
+        var coreLocationOption = new Option<DirectoryInfo>("--core-location", "The location of the .NET Core source code.") { IsRequired = true };
+        var outputOption = new Option<FileInfo>("--output", "The location to write the result.") { IsRequired = true };
+        var command = new Command("build")
+        {
+            coreLocationOption,
+            outputOption,
+        };
+        command.TreatUnmatchedTokensAsErrors = true;
+        command.SetHandler(async (coreLocationDirectory, output) =>
+        {
+            // the tool is expected to be given the path to the .NET Core repository, but the correlator only needs a specific subdirectory
+            var releaseNotesDirectory = new DirectoryInfo(Path.Combine(coreLocationDirectory.FullName, "release-notes"));
+            var correlator = new Correlator(releaseNotesDirectory);
+            var (sdkPackages, _warnings) = await correlator.RunAsync();
+            var json = JsonSerializer.Serialize(sdkPackages, Correlator.SerializerOptions);
+            await File.WriteAllTextAsync(output.FullName, json);
+        }, coreLocationOption, outputOption);
+        var exitCode = await command.InvokeAsync(args);
+        return exitCode;
+    }
+}

data/helpers/lib/NuGetUpdater/DotNetPackageCorrelation.Test/CorrelatorTests.cs

@@ -0,0 +1,99 @@
+using Semver;
+
+using Xunit;
+
+namespace DotNetPackageCorrelation.Tests;
+
+public class CorrelatorTests
+{
+    [Fact]
+    public async Task FileHandling_AllFilesShapedAppropriately()
+    {
+        // the JSON and markdown are shaped as expected
+        // we're able to determine from `Runtime.Package/8.0.0` that the corresponding version of `Some.Package` is `1.2.3`
+        var (packageMapper, warnings) = await PackageMapperFromFilesAsync(
+            ("8.0/releases.json", """
+                {
+                    "releases": [
+                        {
+                            "sdk": {
+                                "version": "8.0.100",
+                                "runtime-version": "8.0.0"
+                            }
+                        }
+                    ]
+                }
+                """),
+            ("8.0/8.0.0/8.0.0.md", """
+                Package name | Version
+                :-- | :--
+                Runtime.Package | 8.0.0
+                Some.Package | 1.2.3
+                """)
+        );
+        Assert.Empty(warnings);
+        AssertPackageVersion(packageMapper, "Runtime.Package", "8.0.0", "Some.Package", "1.2.3");
+    }
+
+    [Theory]
+    [InlineData("Some.Package | 1.2.3", "Some.Package", "1.2.3")] // happy path
+    [InlineData("Some.Package.1.2.3", "Some.Package", "1.2.3")] // looks like a restore directory
+    [InlineData("Some.Package | 1.2 | 1.2.3.nupkg", "Some.Package", "1.2.3")] // extra columns from a bad filename split
+    [InlineData("Some.Package | 1.2.3.nupkg", "Some.Package", "1.2.3")] // version contains package extension
+    [InlineData("Some.Package | 1.2.3.symbols.nupkg", "Some.Package", "1.2.3")] // version contains symbols package extension
+    [InlineData("some.package.1.2.3.nupkg", "some.package", "1.2.3")] // first column is a filename, second column is missing
+    [InlineData("some.package.1.2.3.nupkg |", "some.package", "1.2.3")] // first column is a filename, second column is empty
+    public void PackagesParsedFromMarkdown(string markdownLine, string expectedPackageName, string expectedPackageVersion)
+    {
+        var markdownContent = $"""
+            Package name | Version
+            :-- | :--
+            {markdownLine}
+            """;
+        var warnings = new List<string>();
+        var packages = Correlator.GetPackagesFromMarkdown("test.md", markdownContent, warnings);
+        Assert.Empty(warnings);
+        var actualpackage = Assert.Single(packages);
+        Assert.Equal(expectedPackageName, actualpackage.Name);
+        Assert.Equal(expectedPackageVersion, actualpackage.Version.ToString());
+    }
+
+    private static void AssertPackageVersion(PackageMapper packageMapper, string runtimePackageName, string runtimePackageVersion, string candidatePackageName, string? expectedPackageVersion)
+    {
+        var actualPackageVersion = packageMapper.GetPackageVersionThatShippedWithOtherPackage(runtimePackageName, SemVersion.Parse(runtimePackageVersion), candidatePackageName);
+        if (expectedPackageVersion is null)
+        {
+            Assert.Null(actualPackageVersion);
+        }
+        else
+        {
+            Assert.NotNull(actualPackageVersion);
+            Assert.Equal(expectedPackageVersion, actualPackageVersion.ToString());
+        }
+    }
+
+    private static async Task<(PackageMapper PackageMapper, IEnumerable<string> Warnings)> PackageMapperFromFilesAsync(params (string Path, string Content)[] files)
+    {
+        var testDirectory = Path.Combine(Path.GetDirectoryName(typeof(CorrelatorTests).Assembly.Location)!, "test-data", Guid.NewGuid().ToString("D"));
+        Directory.CreateDirectory(testDirectory);
+
+        try
+        {
+            foreach (var (path, content) in files)
+            {
+                var fullPath = Path.Combine(testDirectory, path);
+                Directory.CreateDirectory(Path.GetDirectoryName(fullPath)!);
+                await File.WriteAllTextAsync(fullPath, content);
+            }
+
+            var correlator = new Correlator(new DirectoryInfo(testDirectory));
+            var (runtimePackages, warnings) = await correlator.RunAsync();
+            var packageMapper = PackageMapper.Load(runtimePackages);
+            return (packageMapper, warnings);
+        }
+        finally
+        {
+            Directory.Delete(testDirectory, recursive: true);
+        }
+    }
+}

data/helpers/lib/NuGetUpdater/DotNetPackageCorrelation.Test/DotNetPackageCorrelation.Test.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>$(CommonTargetFramework)</TargetFramework>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DotNetPackageCorrelation\DotNetPackageCorrelation.csproj" />
+  </ItemGroup>
+
+</Project>

data/helpers/lib/NuGetUpdater/DotNetPackageCorrelation.Test/EndToEndTests.cs

@@ -0,0 +1,30 @@
+using System.Runtime.CompilerServices;
+
+using Semver;
+
+using Xunit;
+
+namespace DotNetPackageCorrelation.Tests;
+
+public class EndToEndTests
+{
+    [Fact]
+    public async Task IntegrationTest()
+    {
+        // arrange
+        var thisFileDirectory = Path.GetDirectoryName(GetThisFilePath())!;
+        var dotnetCoreDirectory = Path.Combine(thisFileDirectory, "..", "..", "dotnet-core");
+        var correlator = new Correlator(new DirectoryInfo(Path.Combine(dotnetCoreDirectory, "release-notes")));
+
+        // act
+        var (runtimePackages, _warnings) = await correlator.RunAsync();
+        var packageMapper = PackageMapper.Load(runtimePackages);
+
+        // assert
+        // Microsoft.NETCore.App.Ref/8.0.8 didn't ship with System.Text.Json, but the previous version 8.0.7 shipped at the same time as System.Text.Json/8.0.4
+        var systemTextJsonVersion = packageMapper.GetPackageVersionThatShippedWithOtherPackage("Microsoft.NETCore.App.Ref", SemVersion.Parse("8.0.8"), "System.Text.Json");
+        Assert.Equal("8.0.4", systemTextJsonVersion?.ToString());
+    }
+
+    private static string GetThisFilePath([CallerFilePath] string? path = null) => path ?? throw new ArgumentNullException(nameof(path));
+}