dependabot-nuget 0.240.0 → 0.241.0

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

@@ -0,0 +1,15 @@
+using System.IO;
+
+namespace NuGetUpdater.Core;
+
+internal static class NuGetHelper
+{
+    internal const string PackagesConfigFileName = "packages.config";
+
+    public static bool HasProjectConfigFile(string projectPath)
+    {
+        var projectDirectory = Path.GetDirectoryName(projectPath);
+        var packagesConfigPath = PathHelper.JoinPath(projectDirectory, PackagesConfigFileName);
+        return File.Exists(packagesConfigPath);
+    }
+}

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

@@ -0,0 +1,69 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace NuGetUpdater.Core;
+
+internal static class PathHelper
+{
+    private static readonly EnumerationOptions _caseInsensitiveEnumerationOptions = new()
+    {
+        MatchCasing = MatchCasing.CaseInsensitive,
+    };
+    private static readonly EnumerationOptions _caseSensitiveEnumerationOptions = new()
+    {
+        MatchCasing = MatchCasing.CaseSensitive,
+    };
+
+    public static string JoinPath(string? path1, string path2)
+    {
+        // don't root out the second path
+        if (path2.StartsWith('/'))
+        {
+            path2 = path2[1..];
+        }
+
+        return path1 is null
+            ? path2
+            : Path.Combine(path1, path2);
+    }
+
+    public static string NormalizePathToUnix(this string path) => path.Replace("\\", "/");
+
+    public static string GetFullPathFromRelative(string rootPath, string relativePath)
+        => Path.GetFullPath(JoinPath(rootPath, relativePath.NormalizePathToUnix()));
+
+    /// <summary>
+    /// Check in every directory from <paramref name="initialPath"/> up to <paramref name="rootPath"/> for the file specified in <paramref name="fileName"/>.
+    /// </summary>
+    /// <returns>The path of the found file or null.</returns>
+    public static string? GetFileInDirectoryOrParent(string initialPath, string rootPath, string fileName, bool caseSensitive = true)
+    {
+        var candidatePaths = new List<string>();
+        var rootDirectory = new DirectoryInfo(rootPath);
+        var candidateDirectory = new DirectoryInfo(initialPath);
+        while (candidateDirectory.FullName != rootDirectory.FullName)
+        {
+            candidatePaths.Add(candidateDirectory.FullName);
+            candidateDirectory = candidateDirectory.Parent;
+            if (candidateDirectory is null)
+            {
+                break;
+            }
+        }
+
+        candidatePaths.Add(rootPath);
+
+        foreach (var candidatePath in candidatePaths)
+        {
+            var files = Directory.EnumerateFiles(candidatePath, fileName, caseSensitive ? _caseSensitiveEnumerationOptions : _caseInsensitiveEnumerationOptions);
+
+            if (files.Any())
+            {
+                return files.First();
+            }
+        }
+
+        return null;
+    }
+}

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

@@ -0,0 +1,66 @@
+using System;
+using System.Diagnostics;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NuGetUpdater.Core;
+
+public static class ProcessEx
+{
+    public static Task<(int ExitCode, string Output, string Error)> RunAsync(string fileName, string arguments = "", string? workingDirectory = null)
+    {
+        var tcs = new TaskCompletionSource<(int, string, string)>();
+
+        var process = new Process
+        {
+            StartInfo =
+            {
+                FileName = fileName,
+                Arguments = arguments,
+                UseShellExecute = false, // required to redirect output
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+            },
+            EnableRaisingEvents = true
+        };
+
+        if (workingDirectory is not null)
+        {
+            process.StartInfo.WorkingDirectory = workingDirectory;
+        }
+
+        var stdout = new StringBuilder();
+        var stderr = new StringBuilder();
+
+        process.OutputDataReceived += (_, e) => stdout.AppendLine(e.Data);
+        process.ErrorDataReceived += (_, e) => stderr.AppendLine(e.Data);
+
+        process.Exited += (sender, args) =>
+        {
+            tcs.TrySetResult((process.ExitCode, stdout.ToString(), stderr.ToString()));
+            process.Dispose();
+        };
+
+#if DEBUG
+        // don't hang when running locally
+        var timeout = TimeSpan.FromSeconds(20);
+        Task.Delay(timeout).ContinueWith(_ =>
+        {
+            if (!tcs.Task.IsCompleted && !Debugger.IsAttached)
+            {
+                tcs.SetException(new Exception($"Process failed to exit after {timeout.TotalSeconds} seconds: {fileName} {arguments}\nstdout:\n{stdout}\n\nstderr:\n{stderr}"));
+            }
+        });
+#endif
+
+        if (!process.Start())
+        {
+            throw new InvalidOperationException("Process failed to start");
+        }
+
+        process.BeginOutputReadLine();
+        process.BeginErrorReadLine();
+
+        return tcs.Task;
+    }
+}

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

@@ -0,0 +1,124 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using Microsoft.Language.Xml;
+
+namespace NuGetUpdater.Core;
+
+public static class XmlExtensions
+{
+    public static string? GetAttributeOrSubElementValue(this IXmlElementSyntax element, string name, StringComparison comparisonType = StringComparison.Ordinal)
+    {
+        var attribute = element.GetAttribute(name, comparisonType);
+        if (attribute is not null)
+        {
+            return attribute.Value;
+        }
+
+        var subElement = element.GetElements(name, comparisonType).FirstOrDefault();
+        return subElement?.GetContentValue();
+    }
+
+    public static IEnumerable<IXmlElementSyntax> GetElements(this IXmlElementSyntax element, string name, StringComparison comparisonType = StringComparison.Ordinal)
+    {
+        return element.Elements.Where(a => a.Name.Equals(name, comparisonType));
+    }
+
+    public static XmlAttributeSyntax? GetAttribute(this IXmlElementSyntax element, string name, StringComparison comparisonType)
+    {
+        return element.Attributes.FirstOrDefault(a => a.Name.Equals(name, comparisonType));
+    }
+
+    public static string GetAttributeValue(this IXmlElementSyntax element, string name, StringComparison comparisonType)
+    {
+        return element.Attributes.First(a => a.Name.Equals(name, comparisonType)).Value;
+    }
+
+    public static XmlAttributeSyntax? GetAttributeCaseInsensitive(this IXmlElementSyntax xml, string name) => GetAttribute(xml, name, StringComparison.OrdinalIgnoreCase);
+
+    public static string? GetAttributeValueCaseInsensitive(this IXmlElementSyntax xml, string name) => xml.GetAttributeCaseInsensitive(name)?.Value;
+
+    public static IXmlElementSyntax WithChildElement(this IXmlElementSyntax parent, string name)
+    {
+        var element = CreateOpenCloseXmlElementSyntax(name);
+        return parent.AddChild(element);
+    }
+
+    public static IXmlElementSyntax WithEmptyChildElement(this IXmlElementSyntax parent, string name)
+    {
+        var element = CreateSingleLineXmlElementSyntax(name);
+        return parent.AddChild(element);
+    }
+
+    public static IXmlElementSyntax WithContent(this IXmlElementSyntax element, string text)
+    {
+        var textSyntax = SyntaxFactory.XmlText(SyntaxFactory.Token(null, SyntaxKind.XmlTextLiteralToken, null, text));
+        return element.WithContent(SyntaxFactory.SingletonList(textSyntax));
+    }
+
+    public static IXmlElementSyntax WithAttribute(this IXmlElementSyntax parent, string name, string value)
+    {
+        var singleSpanceTrivia = SyntaxFactory.WhitespaceTrivia(" ");
+
+        return parent.AddAttribute(SyntaxFactory.XmlAttribute(
+            SyntaxFactory.XmlName(null, SyntaxFactory.XmlNameToken(name, null, null)),
+            SyntaxFactory.Punctuation(SyntaxKind.EqualsToken, "=", null, null),
+            SyntaxFactory.XmlString(
+                SyntaxFactory.Punctuation(SyntaxKind.SingleQuoteToken, "\"", null, null),
+                SyntaxFactory.XmlTextLiteralToken(value, null, null),
+                SyntaxFactory.Punctuation(SyntaxKind.SingleQuoteToken, "\"", null, singleSpanceTrivia))));
+    }
+
+    public static XmlElementSyntax CreateOpenCloseXmlElementSyntax(string name, int indentation = 2, bool spaces = true)
+    {
+        var leadingTrivia = SyntaxFactory.WhitespaceTrivia(new string(' ', indentation));
+        return CreateOpenCloseXmlElementSyntax(name, new SyntaxList<SyntaxNode>(leadingTrivia));
+    }
+
+    public static XmlElementSyntax CreateOpenCloseXmlElementSyntax(string name, SyntaxList<SyntaxNode> leadingTrivia)
+    {
+        var newlineTrivia = SyntaxFactory.WhitespaceTrivia(Environment.NewLine);
+
+        return SyntaxFactory.XmlElement(
+            SyntaxFactory.XmlElementStartTag(
+                SyntaxFactory.Punctuation(SyntaxKind.LessThanToken, "<", leadingTrivia, default),
+                SyntaxFactory.XmlName(null, SyntaxFactory.XmlNameToken(name, null, null)),
+                new SyntaxList<XmlAttributeSyntax>(),
+                SyntaxFactory.Punctuation(SyntaxKind.GreaterThanToken, ">", null, newlineTrivia)),
+            new SyntaxList<SyntaxNode>(),
+            SyntaxFactory.XmlElementEndTag(
+                SyntaxFactory.Punctuation(SyntaxKind.LessThanSlashToken, "</", leadingTrivia, default),
+                SyntaxFactory.XmlName(null, SyntaxFactory.XmlNameToken(name, null, null)),
+                SyntaxFactory.Punctuation(SyntaxKind.GreaterThanToken, ">", null, null)));
+    }
+
+    public static XmlEmptyElementSyntax CreateSingleLineXmlElementSyntax(string name, int indentation = 2, bool spaces = true)
+    {
+        var leadingTrivia = SyntaxFactory.WhitespaceTrivia(new string(' ', indentation));
+        var followingTrivia = SyntaxFactory.WhitespaceTrivia(Environment.NewLine);
+
+        return CreateSingleLineXmlElementSyntax(name, new SyntaxList<SyntaxNode>(leadingTrivia), new SyntaxList<SyntaxNode>(followingTrivia));
+    }
+
+    public static XmlEmptyElementSyntax CreateSingleLineXmlElementSyntax(string name, SyntaxList<SyntaxNode> leadingTrivia, SyntaxList<SyntaxNode> trailingTrivia = default)
+    {
+        var singleSpanceTrivia = SyntaxFactory.WhitespaceTrivia(" ");
+
+        return SyntaxFactory.XmlEmptyElement(
+            SyntaxFactory.Punctuation(SyntaxKind.LessThanToken, "<", leadingTrivia, default),
+            SyntaxFactory.XmlName(null, SyntaxFactory.XmlNameToken(name, null, singleSpanceTrivia)),
+            attributes: new SyntaxList<SyntaxNode>(),
+            SyntaxFactory.Punctuation(SyntaxKind.SlashGreaterThanToken, "/>", default, trailingTrivia));
+    }
+
+    public static IXmlElementSyntax ReplaceAttribute(this IXmlElementSyntax element, XmlAttributeSyntax oldAttribute, XmlAttributeSyntax newAttribute)
+    {
+        return element.WithAttributes(element.AttributesNode.Replace(oldAttribute, newAttribute));
+    }
+
+    public static IXmlElementSyntax ReplaceChildElement(this IXmlElementSyntax element, IXmlElementSyntax oldChildElement, IXmlElementSyntax newChildElement)
+    {
+        return element.WithContent(element.Content.Replace(oldChildElement.AsNode, newChildElement.AsNode));
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Files/DotNetToolsJsonBuildFileTests.cs

@@ -0,0 +1,52 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Files;
+
+public class DotnetToolsJsonBuildFileTests
+{
+    [StringSyntax(StringSyntaxAttribute.Json)]
+    const string DotnetToolsJson = """
+        {
+          "version": 1,
+          "isRoot": true,
+          "tools": {
+            "microsoft.botsay": {
+              "version": "1.0.0",
+              "commands": [
+                "botsay"
+              ]
+            },
+            "dotnetsay": {
+              "version": "2.1.3",
+              "commands": [
+                "dotnetsay"
+              ]
+            }
+          }
+        }
+        """;
+
+    private static DotNetToolsJsonBuildFile GetBuildFile() => new(
+        repoRootPath: "/",
+        path: "/.config/dotnet-tools.json",
+        contents: DotnetToolsJson);
+
+    [Fact]
+    public void GetDependencies_ReturnsDependencies()
+    {
+        var expectedDependencies = new List<Dependency>
+        {
+            new("microsoft.botsay", "1.0.0", DependencyType.DotNetTool),
+            new("dotnetsay", "2.1.3", DependencyType.DotNetTool)
+        };
+
+        var buildFile = GetBuildFile();
+
+        var dependencies = buildFile.GetDependencies();
+
+        Assert.Equal(expectedDependencies, dependencies);
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Files/GlobalJsonBuildFileTests.cs

@@ -0,0 +1,63 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Files;
+
+public class GlobalJsonBuildFileTests
+{
+    [StringSyntax(StringSyntaxAttribute.Json)]
+    const string GlobalJson = """
+        {
+          "sdk": {
+            "version": "6.0.405",
+            "rollForward": "latestPatch"
+          },
+          "msbuild-sdks": {
+            "My.Custom.Sdk": "5.0.0",
+            "My.Other.Sdk": "1.0.0-beta"
+          }
+        }
+        """;
+
+    [StringSyntax(StringSyntaxAttribute.Json)]
+    const string EmptyGlobalJson = """
+        {
+        }
+        """;
+
+    private static GlobalJsonBuildFile GetBuildFile(string contents) => new(
+        repoRootPath: "/",
+        path: "/global.json",
+        contents: contents);
+
+    [Fact]
+    public void GlobalJson_GetDependencies_ReturnsDependencies()
+    {
+        var expectedDependencies = new List<Dependency>
+        {
+            new("My.Custom.Sdk", "5.0.0", DependencyType.MSBuildSdk),
+            new("My.Other.Sdk", "1.0.0-beta", DependencyType.MSBuildSdk)
+        };
+
+        var buildFile = GetBuildFile(GlobalJson);
+
+        var dependencies = buildFile.GetDependencies();
+
+        Assert.Equal(expectedDependencies, dependencies);
+    }
+
+    [Fact]
+    public void EmptyGlobalJson_GetDependencies_ReturnsNoDependencies()
+    {
+        var expectedDependencies = Enumerable.Empty<Dependency>();
+
+        var buildFile = GetBuildFile(EmptyGlobalJson);
+
+        var dependencies = buildFile.GetDependencies();
+
+        Assert.Equal(expectedDependencies, dependencies);
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Files/PackagesConfigBuildFileTests.cs

@@ -0,0 +1,63 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+
+using Microsoft.Language.Xml;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Files;
+
+public class PackagesConfigBuildFileTests
+{
+    [StringSyntax(StringSyntaxAttribute.Xml)]
+    const string PackagesConfig = """
+        <?xml version="1.0" encoding="utf-8"?>
+        <packages>
+          <package id="Microsoft.CodeDom.Providers.DotNetCompilerPlatform" version="1.0.0" targetFramework="net46" />
+          <package id="Microsoft.Net.Compilers" version="1.0.0" targetFramework="net46" developmentDependency="true" />
+          <package id="Newtonsoft.Json" version="8.0.3" allowedVersions="[8,10)" targetFramework="net46" />
+        </packages>
+        """;
+
+    [StringSyntax(StringSyntaxAttribute.Xml)]
+    const string EmptyPackagesConfig = """
+        <?xml version="1.0" encoding="utf-8"?>
+        <packages>
+        </packages>
+        """;
+
+    private static PackagesConfigBuildFile GetBuildFile(string contents) => new(
+        repoRootPath: "/",
+        path: "/packages.config",
+        contents: Parser.ParseText(contents));
+
+    [Fact]
+    public void PackagesConfig_GetDependencies_ReturnsDependencies()
+    {
+        var expectedDependencies = new List<Dependency>
+        {
+            new("Microsoft.CodeDom.Providers.DotNetCompilerPlatform", "1.0.0", DependencyType.PackageConfig),
+            new("Microsoft.Net.Compilers", "1.0.0", DependencyType.PackageConfig, true),
+            new("Newtonsoft.Json", "8.0.3", DependencyType.PackageConfig)
+        };
+
+        var buildFile = GetBuildFile(PackagesConfig);
+
+        var dependencies = buildFile.GetDependencies();
+
+        Assert.Equal(expectedDependencies, dependencies);
+    }
+
+    [Fact]
+    public void EmptyPackagesConfig_GetDependencies_ReturnsNoDependencies()
+    {
+        var expectedDependencies = Enumerable.Empty<Dependency>();
+
+        var buildFile = GetBuildFile(EmptyPackagesConfig);
+
+        var dependencies = buildFile.GetDependencies();
+
+        Assert.Equal(expectedDependencies, dependencies);
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Files/ProjectBuildFileTests.cs

@@ -0,0 +1,154 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+using Microsoft.Language.Xml;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Files;
+
+public class ProjectBuildFileTests
+{
+    [StringSyntax(StringSyntaxAttribute.Xml)]
+    const string ProjectCsProj = """
+        <Project Sdk="Microsoft.NET.Sdk">
+          <PropertyGroup>
+            <OutputType>Exe</OutputType>
+            <TargetFramework>net7.0</TargetFramework>
+          </PropertyGroup>
+          <ItemGroup>
+            <ProjectReference Include=".\Library\Library.csproj" />
+          </ItemGroup>
+          <ItemGroup>
+            <PackageReference Include="GuiLabs.Language.Xml" Version="1.2.60" />
+            <PackageReference Include="Microsoft.CodeAnalysis.CSharp" />
+            <PackageReference Update="Newtonsoft.Json" VersionOverride="13.0.3" />
+          </ItemGroup>
+        </Project>
+        """;
+
+    [StringSyntax(StringSyntaxAttribute.Xml)]
+    const string EmptyProject = """
+        <Project>
+        </Project>
+        """;
+
+    [StringSyntax(StringSyntaxAttribute.Xml)]
+    const string DirectoryPackagesProps = """
+        <Project>
+          <PropertyGroup>
+            <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+            <CentralPackageTransitivePinningEnabled>true</CentralPackageTransitivePinningEnabled>
+          </PropertyGroup>
+          <ItemGroup>
+            <GlobalPackageReference Include="Microsoft.CodeAnalysis.Common" Version="$(RoslynVersion)" />
+            <PackageVersion Include="Newtonsoft.Json" VersionOverride="13.0.1" />
+          </ItemGroup>
+        </Project>
+        """;
+
+    private static ProjectBuildFile GetBuildFile(string contents, string filename) => new(
+        repoRootPath: "/",
+        path: $"/{filename}",
+        contents: Parser.ParseText(contents));
+
+    [Fact]
+    public void ProjectCsProj_GetDependencies_ReturnsDependencies()
+    {
+        var expectedDependencies = new List<Dependency>
+        {
+            new("GuiLabs.Language.Xml", "1.2.60", DependencyType.PackageReference),
+            new("Microsoft.CodeAnalysis.CSharp", null, DependencyType.PackageReference),
+            new("Newtonsoft.Json", "13.0.3", DependencyType.PackageReference, IsOverride: true)
+        };
+
+        var buildFile = GetBuildFile(ProjectCsProj, "Project.csproj");
+
+        var dependencies = buildFile.GetDependencies();
+
+        Assert.Equal(expectedDependencies, dependencies);
+    }
+
+    [Fact]
+    public void ProjectCsProj_ReferencedProjectPaths_ReturnsPaths()
+    {
+        var expectedReferencedProjectPaths = new List<string>
+        {
+            "/Library/Library.csproj"
+        };
+
+        var buildFile = GetBuildFile(ProjectCsProj, "Project.csproj");
+
+        var referencedProjectPaths = buildFile.GetReferencedProjectPaths()
+            .Select(p => Regex.IsMatch(p, @"^[A-Z]:\\") ? "/" + p.Substring(@"C:\".Length) : p) // remove drive letter when testing on Windows
+            .Select(p => p.NormalizePathToUnix());
+
+        Assert.Equal(expectedReferencedProjectPaths, referencedProjectPaths);
+    }
+
+    [Fact]
+    public void DirectoryPackagesProps_GetDependencies_ReturnsDependencies()
+    {
+        var expectedDependencies = new List<Dependency>
+        {
+            new("Microsoft.CodeAnalysis.Common", "$(RoslynVersion)", DependencyType.GlobalPackageReference),
+            new("Newtonsoft.Json", "13.0.1", DependencyType.PackageVersion, IsOverride: true)
+        };
+
+        var buildFile = GetBuildFile(DirectoryPackagesProps, "Directory.Packages.props");
+
+        var dependencies = buildFile.GetDependencies();
+
+        Assert.Equal(expectedDependencies, dependencies);
+    }
+
+    [Fact]
+    public void DirectoryPackagesProps_Properties_ReturnsProperties()
+    {
+        var expectedProperties = new List<KeyValuePair<string, string>>
+        {
+            new("ManagePackageVersionsCentrally", "true"),
+            new("CentralPackageTransitivePinningEnabled", "true")
+        };
+
+        var buildFile = GetBuildFile(DirectoryPackagesProps, "Directory.Packages.props");
+
+        var properties = buildFile.GetProperties();
+
+        Assert.Equal(expectedProperties, properties);
+    }
+
+    [Fact]
+    public void EmptyProject_GetDependencies_ReturnsNoDependencies()
+    {
+        var expectedDependencies = Enumerable.Empty<Dependency>();
+
+        var buildFile = GetBuildFile(EmptyProject, "project.csproj");
+
+        var dependencies = buildFile.GetDependencies();
+
+        Assert.Equal(expectedDependencies, dependencies);
+    }
+
+    [Theory]
+    [InlineData( // no change made
+    @"<Project><ItemGroup><Reference><HintPath>path\to\file.dll</HintPath></Reference></ItemGroup></Project>",
+    @"<Project><ItemGroup><Reference><HintPath>path\to\file.dll</HintPath></Reference></ItemGroup></Project>"
+    )]
+    [InlineData( // change from `/` to `\`
+    "<Project><ItemGroup><Reference><HintPath>path/to/file.dll</HintPath></Reference></ItemGroup></Project>",
+    @"<Project><ItemGroup><Reference><HintPath>path\to\file.dll</HintPath></Reference></ItemGroup></Project>"
+    )]
+    [InlineData( // multiple changes made
+    "<Project><ItemGroup><Reference><HintPath>path1/to1/file1.dll</HintPath></Reference><Reference><HintPath>path2/to2/file2.dll</HintPath></Reference></ItemGroup></Project>",
+    @"<Project><ItemGroup><Reference><HintPath>path1\to1\file1.dll</HintPath></Reference><Reference><HintPath>path2\to2\file2.dll</HintPath></Reference></ItemGroup></Project>"
+    )]
+    public void ReferenceHintPathsCanBeNormalized(string originalXml, string expectedXml)
+    {
+        ProjectBuildFile? buildFile = GetBuildFile(originalXml, "project.csproj");
+        buildFile.NormalizeDirectorySeparatorsInProject();
+        Assert.Equal(expectedXml, buildFile.Contents.ToFullString());
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/FrameworkChecker/CompatibilityCheckerFacts.cs

@@ -0,0 +1,64 @@
+using NuGetUpdater.Core.FrameworkChecker;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.FrameworkChecker;
+
+public class CompatibilityCheckerFacts
+{
+    [Theory]
+    [InlineData("net8.0", "net8.0")]
+    [InlineData("net8.0", "net7.0")]
+    [InlineData("net7.0", "net7.0")]
+    [InlineData("net7.0", "net6.0")]
+    [InlineData("net7.0", "net5.0")]
+    [InlineData("net7.0", "netcoreapp3.1")]
+    [InlineData("net7.0", "netstandard2.1")]
+    [InlineData("net7.0", "netstandard2.0")]
+    [InlineData("net7.0", "netstandard1.3")]
+    [InlineData("net4.8", "netstandard2.0")]
+    [InlineData("net4.8", "netstandard1.3")]
+    public void PackageContainsCompatibleFramework(string projectTfm, string packageTfm)
+    {
+        var result = CompatibilityChecker.IsCompatible(new[] { projectTfm }, new[] { packageTfm }, new Logger(verbose: true));
+
+        Assert.True(result);
+    }
+
+    [Theory]
+    [InlineData("net48", "netcoreapp3.1")]
+    [InlineData("net48", "netstandard2.1")]
+    [InlineData("net7.0", "net8.0")]
+    [InlineData("net6.0", "net7.0")]
+    [InlineData("net5.0", "net6.0")]
+    [InlineData("netcoreapp3.1", "net5.0")]
+    [InlineData("netstandard2.0", "netstandard2.1")]
+    [InlineData("netstandard1.3", "netstandard2.0")]
+    [InlineData("net7.0", "net48")]
+    public void PackageContainsIncompatibleFramework(string projectTfm, string packageTfm)
+    {
+        var result = CompatibilityChecker.IsCompatible(new[] { projectTfm }, new[] { packageTfm }, new Logger(verbose: true));
+
+        Assert.False(result);
+    }
+
+    [Theory]
+    [InlineData(new[] { "net8.0", "net7.0", "net472" }, new[] { "netstandard2.0" })]
+    [InlineData(new[] { "net8.0", "net7.0", "net472" }, new[] { "net5.0", "net461" })]
+    [InlineData(new[] { "net6.0", "net6.0-windows10.0.19041" }, new[] { "net6.0", ".NETStandard2.0" })]
+    public void PackageContainsCompatibleFrameworks(string[] projectTfms, string[] packageTfms)
+    {
+        var result = CompatibilityChecker.IsCompatible(projectTfms, packageTfms, new Logger(verbose: true));
+
+        Assert.True(result);
+    }
+
+    [Theory]
+    [InlineData(new[] { "net7.0", "net472" }, new[] { "net5.0" })]
+    public void PackageContainsIncompatibleFrameworks(string[] projectTfms, string[] packageTfms)
+    {
+        var result = CompatibilityChecker.IsCompatible(projectTfms, packageTfms, new Logger(verbose: true));
+
+        Assert.False(result);
+    }
+}