dependabot-nuget 0.262.0 → 0.264.0

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

@@ -78,8 +78,10 @@ internal static class SdkPackageUpdater
                 tfm,
                 topLevelDependencies,
                 logger);
-            foreach (var (packageName, packageVersion, _, _, _, _, _, _, _, _) in dependencies)
+            foreach (var dependency in dependencies)
             {
+                var packageName = dependency.Name;
+                var packageVersion = dependency.Version;
                 if (packageVersion is null)
                 {
                     continue;
@@ -263,8 +265,10 @@ internal static class SdkPackageUpdater
         var packagesAndVersions = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
         foreach (var (_, dependencies) in tfmsAndDependencies)
         {
-            foreach (var (packageName, packageVersion, _, _, _, _, _, _, _, _) in dependencies)
+            foreach (var dependency in dependencies)
             {
+                var packageName = dependency.Name;
+                var packageVersion = dependency.Version;
                 if (packagesAndVersions.TryGetValue(packageName, out var existingVersion) &&
                     existingVersion != packageVersion)
                 {

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

@@ -1,7 +1,3 @@
-using System;
-using System.IO;
-using System.Linq;
-
 using Microsoft.Language.Xml;
 
 namespace NuGetUpdater.Core.Updater

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

@@ -1,5 +1,3 @@
-using System;
-
 using Microsoft.Language.Xml;
 
 namespace NuGetUpdater.Core.Updater

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

@@ -1,5 +1,3 @@
-using System.Collections.Immutable;
-
 namespace NuGetUpdater.Core.Utilities;
 
 public static class HashSetExtensions

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

@@ -1,7 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text;
 using System.Text.Encodings.Web;

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

@@ -1,6 +1,3 @@
-using System;
-using System.IO;
-
 namespace NuGetUpdater.Core;
 
 public sealed class Logger

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

@@ -231,11 +231,7 @@ internal static partial class MSBuildHelper
                 ? evaluationResult.EvaluatedValue.TrimStart('[', '(').TrimEnd(']', ')')
                 : evaluationResult.EvaluatedValue;
 
-            // We don't know the version for range requirements or wildcard
-            // requirements, so return "" for these.
-            yield return packageVersion.Contains(',') || packageVersion.Contains('*')
-                ? new Dependency(name, string.Empty, dependencyType, EvaluationResult: evaluationResult, IsUpdate: isUpdate)
-                : new Dependency(name, packageVersion, dependencyType, EvaluationResult: evaluationResult, IsUpdate: isUpdate);
+            yield return new Dependency(name, packageVersion, dependencyType, EvaluationResult: evaluationResult, IsUpdate: isUpdate);
         }
     }
 
@@ -483,11 +479,13 @@ internal static partial class MSBuildHelper
                     // if the source is relative to the original location, copy it to the temp directory
                     if (PathHelper.IsSubdirectoryOf(nugetConfigDir!, localSource.Source))
                     {
-                        string sourceRelativePath = Path.GetRelativePath(nugetConfigDir!, localSource.Source);
+                        // normalize the directory separators and copy the contents
+                        string localSourcePath = localSource.Source.Replace("\\", "/");
+                        string sourceRelativePath = Path.GetRelativePath(nugetConfigDir!, localSourcePath);
                         string destPath = Path.Join(tempDir.FullName, sourceRelativePath);
-                        if (Directory.Exists(localSource.Source))
+                        if (Directory.Exists(localSourcePath))
                         {
-                            PathHelper.CopyDirectory(localSource.Source, destPath);
+                            PathHelper.CopyDirectory(localSourcePath, destPath);
                         }
                     }
                 }
@@ -542,6 +540,7 @@ internal static partial class MSBuildHelper
               <PropertyGroup>
                 <!-- For Windows-specific apps -->
                 <EnableWindowsTargeting>true</EnableWindowsTargeting>
+                <!-- Really ensure CPM is disabled -->
                 <ManagePackageVersionsCentrally>false</ManagePackageVersionsCentrally>
               </PropertyGroup>
             </Project>

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

@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-
 namespace NuGetUpdater.Core;
 
 internal static class PathHelper

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

@@ -1,8 +1,5 @@
-using System;
 using System.Diagnostics;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace NuGetUpdater.Core;
 

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

@@ -1,7 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
 using Microsoft.Language.Xml;
 
 namespace NuGetUpdater.Core;

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

@@ -0,0 +1,90 @@
+using System.Collections.Immutable;
+using System.Text.Json;
+
+using NuGetUpdater.Core.Analyze;
+using NuGetUpdater.Core.Discover;
+using NuGetUpdater.Core.Test.Update;
+using NuGetUpdater.Core.Test.Utilities;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Analyze;
+
+using TestFile = (string Path, string Content);
+
+public class AnalyzeWorkerTestBase
+{
+    protected static async Task TestAnalyzeAsync(
+        WorkspaceDiscoveryResult discovery,
+        DependencyInfo dependencyInfo,
+        ExpectedAnalysisResult expectedResult,
+        MockNuGetPackage[]? packages = null)
+    {
+        var relativeDependencyPath = $"./dependabot/dependency/{dependencyInfo.Name}.json";
+
+        TestFile[] files = [
+            (DiscoveryWorker.DiscoveryResultFileName, JsonSerializer.Serialize(discovery, AnalyzeWorker.SerializerOptions)),
+            (relativeDependencyPath, JsonSerializer.Serialize(dependencyInfo, AnalyzeWorker.SerializerOptions)),
+        ];
+
+        var actualResult = await RunAnalyzerAsync(dependencyInfo.Name, files, async directoryPath =>
+        {
+            await UpdateWorkerTestBase.MockNuGetPackagesInDirectory(packages, directoryPath);
+
+            var discoveryPath = Path.GetFullPath(DiscoveryWorker.DiscoveryResultFileName, directoryPath);
+            var dependencyPath = Path.GetFullPath(relativeDependencyPath, directoryPath);
+            var analysisPath = Path.GetFullPath(AnalyzeWorker.AnalysisDirectoryName, directoryPath);
+
+            var worker = new AnalyzeWorker(new Logger(verbose: true));
+            await worker.RunAsync(directoryPath, discoveryPath, dependencyPath, analysisPath);
+        });
+
+        ValidateAnalysisResult(expectedResult, actualResult);
+    }
+
+    protected static void ValidateAnalysisResult(ExpectedAnalysisResult expectedResult, AnalysisResult actualResult)
+    {
+        Assert.NotNull(actualResult);
+        Assert.Equal(expectedResult.UpdatedVersion, actualResult.UpdatedVersion);
+        Assert.Equal(expectedResult.CanUpdate, actualResult.CanUpdate);
+        Assert.Equal(expectedResult.VersionComesFromMultiDependencyProperty, actualResult.VersionComesFromMultiDependencyProperty);
+        ValidateDependencies(expectedResult.UpdatedDependencies, actualResult.UpdatedDependencies);
+        Assert.Equal(expectedResult.ExpectedUpdatedDependenciesCount ?? expectedResult.UpdatedDependencies.Length, actualResult.UpdatedDependencies.Length);
+
+        return;
+
+        void ValidateDependencies(ImmutableArray<Dependency> expectedDependencies, ImmutableArray<Dependency> actualDependencies)
+        {
+            if (expectedDependencies.IsDefault)
+            {
+                return;
+            }
+
+            foreach (var expectedDependency in expectedDependencies)
+            {
+                var actualDependency = actualDependencies.Single(d => d.Name == expectedDependency.Name);
+                Assert.Equal(expectedDependency.Name, actualDependency.Name);
+                Assert.Equal(expectedDependency.Version, actualDependency.Version);
+                Assert.Equal(expectedDependency.Type, actualDependency.Type);
+                AssertEx.Equal(expectedDependency.TargetFrameworks, actualDependency.TargetFrameworks);
+                Assert.Equal(expectedDependency.IsDirect, actualDependency.IsDirect);
+                Assert.Equal(expectedDependency.IsTransitive, actualDependency.IsTransitive);
+                Assert.Equal(expectedDependency.InfoUrl, actualDependency.InfoUrl);
+            }
+        }
+    }
+
+    protected static async Task<AnalysisResult> RunAnalyzerAsync(string dependencyName, TestFile[] files, Func<string, Task> action)
+    {
+        // write initial files
+        using var temporaryDirectory = await TemporaryDirectory.CreateWithContentsAsync(files);
+
+        // run discovery
+        await action(temporaryDirectory.DirectoryPath);
+
+        // gather results
+        var resultPath = Path.Join(temporaryDirectory.DirectoryPath, AnalyzeWorker.AnalysisDirectoryName, $"{dependencyName}.json");
+        var resultJson = await File.ReadAllTextAsync(resultPath);
+        return JsonSerializer.Deserialize<AnalysisResult>(resultJson, DiscoveryWorker.SerializerOptions)!;
+    }
+}

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

@@ -0,0 +1,304 @@
+using NuGetUpdater.Core.Analyze;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Analyze;
+
+public partial class AnalyzeWorkerTests : AnalyzeWorkerTestBase
+{
+    [Fact]
+    public async Task FindsUpdatedVersion()
+    {
+        await TestAnalyzeAsync(
+            packages:
+            [
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "1.0.0", "net8.0"), // initially this
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "1.1.0", "net8.0"), // should update to this
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "1.2.0", "net8.0"), // `IgnoredVersions` should prevent this from being selected
+            ],
+            discovery: new()
+            {
+                Path = "/",
+                Projects = [
+                    new()
+                    {
+                        FilePath = "./project.csproj",
+                        TargetFrameworks = ["net8.0"],
+                        Dependencies = [
+                            new("Some.Package", "1.0.0", DependencyType.PackageReference),
+                        ],
+                    },
+                ],
+            },
+            dependencyInfo: new()
+            {
+                Name = "Some.Package",
+                Version = "1.0.0",
+                IgnoredVersions = [Requirement.Parse("> 1.1.0")],
+                IsVulnerable = false,
+                Vulnerabilities = [],
+            },
+            expectedResult: new()
+            {
+                UpdatedVersion = "1.1.0",
+                CanUpdate = true,
+                VersionComesFromMultiDependencyProperty = false,
+                UpdatedDependencies = [
+                    new("Some.Package", "1.1.0", DependencyType.Unknown, TargetFrameworks: ["net8.0"]),
+                ],
+            }
+        );
+    }
+
+    [Fact]
+    public async Task FindsUpdatedPeerDependencies()
+    {
+        await TestAnalyzeAsync(
+            packages:
+            [
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "4.0.1", "net8.0", [(null, [("Some.Transitive.Dependency", "[4.0.1]")])]), // initially this
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "4.9.2", "net8.0", [(null, [("Some.Transitive.Dependency", "[4.9.2]")])]), // should update to this
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "4.9.3", "net8.0", [(null, [("Some.Transitive.Dependency", "[4.9.3]")])]), // will not update this far
+                MockNuGetPackage.CreateSimplePackage("Some.Transitive.Dependency", "4.0.1", "net8.0"),
+                MockNuGetPackage.CreateSimplePackage("Some.Transitive.Dependency", "4.9.2", "net8.0"),
+                MockNuGetPackage.CreateSimplePackage("Some.Transitive.Dependency", "4.9.3", "net8.0"),
+            ],
+            discovery: new()
+            {
+                Path = "/",
+                Projects = [
+                    new()
+                    {
+                        FilePath = "./project.csproj",
+                        TargetFrameworks = ["net8.0"],
+                        Dependencies = [
+                            new("Some.Package", "4.0.1", DependencyType.PackageReference),
+                            new("Some.Transitive.Dependency", "4.0.1", DependencyType.PackageReference),
+                        ],
+                    },
+                ],
+            },
+            dependencyInfo: new()
+            {
+                Name = "Some.Package",
+                Version = "4.0.1",
+                IgnoredVersions = [Requirement.Parse("> 4.9.2")],
+                IsVulnerable = false,
+                Vulnerabilities = [],
+            },
+            expectedResult: new()
+            {
+                UpdatedVersion = "4.9.2",
+                CanUpdate = true,
+                VersionComesFromMultiDependencyProperty = false,
+                UpdatedDependencies = [
+                    new("Some.Package", "4.9.2", DependencyType.Unknown, TargetFrameworks: ["net8.0"]),
+                    new("Some.Transitive.Dependency", "4.9.2", DependencyType.Unknown, TargetFrameworks: ["net8.0"]),
+                ],
+            }
+        );
+    }
+
+    [Fact]
+    public async Task DeterminesMultiPropertyVersion()
+    {
+        var evaluationResult = new EvaluationResult(EvaluationResultType.Success, "$(SomePackageVersion)", "4.0.1", "SomePackageVersion", ErrorMessage: null);
+        await TestAnalyzeAsync(
+            packages:
+            [
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "4.0.1", "net8.0", [(null, [("Some.Transitive.Dependency", "[4.0.1]")])]), // initially this
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "4.9.2", "net8.0", [(null, [("Some.Transitive.Dependency", "[4.9.2]")])]), // should update to this
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "4.9.3", "net8.0", [(null, [("Some.Transitive.Dependency", "[4.9.3]")])]), // will not update this far
+                MockNuGetPackage.CreateSimplePackage("Some.Transitive.Dependency", "4.0.1", "net8.0"),
+                MockNuGetPackage.CreateSimplePackage("Some.Transitive.Dependency", "4.9.2", "net8.0"),
+                MockNuGetPackage.CreateSimplePackage("Some.Transitive.Dependency", "4.9.3", "net8.0"),
+            ],
+            discovery: new()
+            {
+                Path = "/",
+                Projects = [
+                    new()
+                    {
+                        FilePath = "./project.csproj",
+                        TargetFrameworks = ["net8.0"],
+                        Dependencies = [
+                            new("Some.Transitive.Dependency", "4.0.1", DependencyType.PackageReference, EvaluationResult: evaluationResult, TargetFrameworks: ["net8.0"]),
+                        ],
+                    },
+                    new()
+                    {
+                        FilePath = "./project2.csproj",
+                        TargetFrameworks = ["net8.0"],
+                        Dependencies = [
+                            new("Some.Package", "4.0.1", DependencyType.PackageReference, EvaluationResult: evaluationResult, TargetFrameworks: ["net8.0"]),
+                        ],
+                    },
+                ],
+            },
+            dependencyInfo: new()
+            {
+                Name = "Some.Transitive.Dependency",
+                Version = "4.0.1",
+                IgnoredVersions = [Requirement.Parse("> 4.9.2")],
+                IsVulnerable = false,
+                Vulnerabilities = [],
+            },
+            expectedResult: new()
+            {
+                UpdatedVersion = "4.9.2",
+                CanUpdate = true,
+                VersionComesFromMultiDependencyProperty = true,
+                UpdatedDependencies = [
+                    new("Some.Package", "4.9.2", DependencyType.Unknown, TargetFrameworks: ["net8.0"]),
+                    new("Some.Transitive.Dependency", "4.9.2", DependencyType.Unknown, TargetFrameworks: ["net8.0"]),
+                ],
+            }
+        );
+    }
+
+    [Fact]
+    public async Task FailsToUpdateMultiPropertyVersion()
+    {
+        // Package.A and Package.B happen to share some versions but would fail to update in sync with each other.
+        var evaluationResult = new EvaluationResult(EvaluationResultType.Success, "$(TestPackageVersion)", "4.5.0", "TestPackageVersion", ErrorMessage: null);
+        await TestAnalyzeAsync(
+            packages:
+            [
+                MockNuGetPackage.CreateSimplePackage("Package.A", "4.5.0", "net8.0"), // initial package versions match, purely by accident
+                MockNuGetPackage.CreateSimplePackage("Package.A", "4.9.2", "net8.0"), // subsequent versions do not match
+                MockNuGetPackage.CreateSimplePackage("Package.A", "4.9.3", "net8.0"),
+                MockNuGetPackage.CreateSimplePackage("Package.B", "4.5.0", "net8.0"),
+                MockNuGetPackage.CreateSimplePackage("Package.B", "4.5.1", "net8.0"),
+                MockNuGetPackage.CreateSimplePackage("Package.B", "4.5.2", "net8.0"),
+            ],
+            discovery: new()
+            {
+                Path = "/",
+                Projects = [
+                    new()
+                    {
+                        FilePath = "./project.csproj",
+                        TargetFrameworks = ["net8.0"],
+                        Dependencies = [
+                            new("Package.A", "4.5.0", DependencyType.PackageReference, EvaluationResult: evaluationResult, TargetFrameworks: ["net8.0"]),
+                        ],
+                    },
+                    new()
+                    {
+                        FilePath = "./project2.csproj",
+                        TargetFrameworks = ["net8.0"],
+                        Dependencies = [
+                            new("Package.B", "4.5.0", DependencyType.PackageReference, EvaluationResult: evaluationResult, TargetFrameworks: ["net8.0"]),
+                        ],
+                    },
+                ],
+            },
+            dependencyInfo: new()
+            {
+                Name = "Package.A",
+                Version = "4.5.0",
+                IgnoredVersions = [Requirement.Parse("> 4.9.2")],
+                IsVulnerable = false,
+                Vulnerabilities = [],
+            },
+            expectedResult: new()
+            {
+                UpdatedVersion = "4.5.0",
+                CanUpdate = false,
+                VersionComesFromMultiDependencyProperty = true,
+                UpdatedDependencies = [],
+            }
+        );
+    }
+
+
+    [Fact]
+    public async Task ReturnsUpToDate_ForMissingVersionProperty()
+    {
+        await TestAnalyzeAsync(
+            packages:
+            [
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "4.0.1", "net8.0", [(null, [("Some.Transitive.Dependency", "[4.0.1]")])]), // initially this
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "4.9.2", "net8.0", [(null, [("Some.Transitive.Dependency", "[4.9.2]")])]), // should update to this
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "4.9.3", "net8.0", [(null, [("Some.Transitive.Dependency", "[4.9.3]")])]), // will not update this far
+                MockNuGetPackage.CreateSimplePackage("Some.Transitive.Dependency", "4.0.1", "net8.0"),
+                MockNuGetPackage.CreateSimplePackage("Some.Transitive.Dependency", "4.9.2", "net8.0"),
+                MockNuGetPackage.CreateSimplePackage("Some.Transitive.Dependency", "4.9.3", "net8.0"),
+            ],
+            discovery: new()
+            {
+                Path = "/",
+                Projects = [
+                    new()
+                    {
+                        FilePath = "./project.csproj",
+                        TargetFrameworks = ["net8.0"],
+                        Dependencies = [
+                            new("Some.Transitive.Dependency", "$(MissingPackageVersion)", DependencyType.PackageReference, EvaluationResult: new EvaluationResult(EvaluationResultType.PropertyNotFound, "$(MissingPackageVersion)", "$(MissingPackageVersion)", "$(MissingPackageVersion)", ErrorMessage: null)),
+                        ],
+                    },
+                ],
+            },
+            dependencyInfo: new()
+            {
+                Name = "Some.Package",
+                Version = "$(MissingPackageVersion)",
+                IgnoredVersions = [Requirement.Parse("> 4.9.2")],
+                IsVulnerable = false,
+                Vulnerabilities = [],
+            },
+            expectedResult: new()
+            {
+                UpdatedVersion = "$(MissingPackageVersion)",
+                CanUpdate = false,
+                VersionComesFromMultiDependencyProperty = false,
+                UpdatedDependencies = [],
+            }
+        );
+    }
+
+    [Fact]
+    public async Task ReturnsUpToDate_ForMissingDependency()
+    {
+        await TestAnalyzeAsync(
+            packages:
+            [
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "4.0.1", "net8.0", [(null, [("Some.Transitive.Dependency", "[4.0.1]")])]), // initially this
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "4.9.2", "net8.0", [(null, [("Some.Transitive.Dependency", "[4.9.2]")])]), // should update to this
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "4.9.3", "net8.0", [(null, [("Some.Transitive.Dependency", "[4.9.3]")])]), // will not update this far
+                MockNuGetPackage.CreateSimplePackage("Some.Transitive.Dependency", "4.0.1", "net8.0"),
+                MockNuGetPackage.CreateSimplePackage("Some.Transitive.Dependency", "4.9.2", "net8.0"),
+                MockNuGetPackage.CreateSimplePackage("Some.Transitive.Dependency", "4.9.3", "net8.0"),
+            ],
+            discovery: new()
+            {
+                Path = "/",
+                Projects = [
+                    new()
+                    {
+                        FilePath = "./project.csproj",
+                        TargetFrameworks = ["net8.0"],
+                        Dependencies = [
+                            new("Some.Transitive.Dependency", "4.0.1", DependencyType.PackageReference),
+                        ],
+                    },
+                ],
+            },
+            dependencyInfo: new()
+            {
+                Name = "Some.Package",
+                Version = "4.0.1",
+                IgnoredVersions = [Requirement.Parse("> 4.9.2")],
+                IsVulnerable = false,
+                Vulnerabilities = [],
+            },
+            expectedResult: new()
+            {
+                UpdatedVersion = "4.0.1",
+                CanUpdate = false,
+                VersionComesFromMultiDependencyProperty = false,
+                UpdatedDependencies = [],
+            }
+        );
+    }
+}

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

@@ -0,0 +1,145 @@
+using System.Collections.Immutable;
+
+using NuGet.Frameworks;
+using NuGet.Packaging.Core;
+using NuGet.Versioning;
+
+using NuGetUpdater.Core.Analyze;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Analyze;
+
+public class CompatibilityCheckerTests
+{
+    [Fact]
+    public void PerformCheck_CompatiblePackage_IsCompatible()
+    {
+        var package = new PackageIdentity("Dependency", NuGetVersion.Parse("1.0.0"));
+        ImmutableArray<NuGetFramework> projectFrameworks = [
+            NuGetFramework.Parse("net6.0"),
+            NuGetFramework.Parse("netstandard2.0"),
+        ];
+        var isDevDependency = false;
+        ImmutableArray<NuGetFramework> packageFrameworks = [
+            NuGetFramework.Parse("netstandard1.3"),
+        ];
+
+        var result = CompatibilityChecker.PerformCheck(
+            package,
+            projectFrameworks,
+            isDevDependency,
+            packageFrameworks,
+            new Logger(verbose: false));
+
+        Assert.True(result);
+    }
+
+    [Fact]
+    public void PerformCheck_IncompatiblePackage_IsIncompatible()
+    {
+        var package = new PackageIdentity("Dependency", NuGetVersion.Parse("1.0.0"));
+        ImmutableArray<NuGetFramework> projectFrameworks = [
+            NuGetFramework.Parse("net6.0"),
+            NuGetFramework.Parse("netstandard2.0"),
+        ];
+        var isDevDependency = false;
+        ImmutableArray<NuGetFramework> packageFrameworks = [
+            NuGetFramework.Parse("net462"),
+        ];
+
+        var result = CompatibilityChecker.PerformCheck(
+            package,
+            projectFrameworks,
+            isDevDependency,
+            packageFrameworks,
+            new Logger(verbose: false));
+
+        Assert.False(result);
+    }
+
+    [Fact]
+    public void PerformCheck_DevDependencyWithPackageFrameworks_IsChecked()
+    {
+        var package = new PackageIdentity("Dependency", NuGetVersion.Parse("1.0.0"));
+        ImmutableArray<NuGetFramework> projectFrameworks = [
+            NuGetFramework.Parse("net6.0"),
+            NuGetFramework.Parse("netstandard2.0"),
+        ];
+        var isDevDependency = true;
+        ImmutableArray<NuGetFramework> packageFrameworks = [
+            NuGetFramework.Parse("net462"),
+        ];
+
+        var result = CompatibilityChecker.PerformCheck(
+            package,
+            projectFrameworks,
+            isDevDependency,
+            packageFrameworks,
+            new Logger(verbose: false));
+
+        Assert.False(result);
+    }
+
+    [Fact]
+    public void PerformCheck_DevDependencyWithoutPackageFrameworks_IsCompatibile()
+    {
+        var package = new PackageIdentity("Dependency", NuGetVersion.Parse("1.0.0"));
+        ImmutableArray<NuGetFramework> projectFrameworks = [
+            NuGetFramework.Parse("net6.0"),
+            NuGetFramework.Parse("netstandard2.0"),
+        ];
+        var isDevDependency = true;
+        ImmutableArray<NuGetFramework> packageFrameworks = [];
+
+        var result = CompatibilityChecker.PerformCheck(
+            package,
+            projectFrameworks,
+            isDevDependency,
+            packageFrameworks,
+            new Logger(verbose: false));
+
+        Assert.True(result);
+    }
+
+    [Fact]
+    public void PerformCheck_WithoutPackageFrameworks_IsIncompatibile()
+    {
+        var package = new PackageIdentity("Dependency", NuGetVersion.Parse("1.0.0"));
+        ImmutableArray<NuGetFramework> projectFrameworks = [
+            NuGetFramework.Parse("net6.0"),
+            NuGetFramework.Parse("netstandard2.0"),
+        ];
+        var isDevDependency = false;
+        ImmutableArray<NuGetFramework> packageFrameworks = [];
+
+        var result = CompatibilityChecker.PerformCheck(
+            package,
+            projectFrameworks,
+            isDevDependency,
+            packageFrameworks,
+            new Logger(verbose: false));
+
+        Assert.False(result);
+    }
+
+    [Fact]
+    public void PerformCheck_WithoutProjectFrameworks_IsIncompatible()
+    {
+        var package = new PackageIdentity("Dependency", NuGetVersion.Parse("1.0.0"));
+        ImmutableArray<NuGetFramework> projectFrameworks = [];
+        var isDevDependency = true;
+        ImmutableArray<NuGetFramework> packageFrameworks = [
+            NuGetFramework.Parse("netstandard1.3"),
+        ];
+
+        var result = CompatibilityChecker.PerformCheck(
+            package,
+            projectFrameworks,
+            isDevDependency,
+            packageFrameworks,
+            new Logger(verbose: false));
+
+        Assert.False(result);
+    }
+}