dependabot-nuget 0.309.0 → 0.311.0

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

@@ -50,7 +50,8 @@ public class SerializationTests
                 "credentials-metadata": [
                   {
                     "host": "github.com",
-                    "type": "git_source"
+                    "type": "git_source",
+                    "replaces-base": false
                   }
                 ],
                 "max-updater-run-time": 0
@@ -116,7 +117,8 @@ public class SerializationTests
                 "credentials": [
                   {
                     "name": "some-cred",
-                    "token": "abc123"
+                    "token": "abc123",
+                    "replaces-base": false
                   }
                 ],
                 "existing-pull-requests": [

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/TestHttpServer.cs

@@ -10,13 +10,13 @@ namespace NuGetUpdater.Core.Test
 {
     public class TestHttpServer : IDisposable
     {
-        private readonly Func<string, (int, byte[])> _requestHandler;
+        private readonly Func<string, string, (int, byte[])> _requestHandler;
         private readonly HttpListener _listener;
         private bool _runServer = true;
 
         public string BaseUrl { get; }
 
-        private TestHttpServer(string baseurl, Func<string, (int, byte[])> requestHandler)
+        private TestHttpServer(string baseurl, Func<string, string, (int, byte[])> requestHandler)
         {
             BaseUrl = baseurl;
             _requestHandler = requestHandler;
@@ -43,7 +43,7 @@ namespace NuGetUpdater.Core.Test
             while (_runServer)
             {
                 var context = await _listener.GetContextAsync();
-                var (statusCode, response) = _requestHandler(context.Request.Url!.AbsoluteUri);
+                var (statusCode, response) = _requestHandler(context.Request.HttpMethod, context.Request.Url!.AbsoluteUri);
                 context.Response.StatusCode = statusCode;
                 await context.Response.OutputStream.WriteAsync(response);
                 context.Response.Close();
@@ -53,6 +53,11 @@ namespace NuGetUpdater.Core.Test
         private static readonly object PortGate = new();
 
         public static TestHttpServer CreateTestServer(Func<string, (int, byte[])> requestHandler)
+        {
+            return CreateTestServer((method, url) => requestHandler(url));
+        }
+
+        public static TestHttpServer CreateTestServer(Func<string, string, (int, byte[])> requestHandler)
         {
             // static lock to ensure the port is not recycled after `FindFreePort()` and before we can start the real server
             lock (PortGate)
@@ -67,9 +72,14 @@ namespace NuGetUpdater.Core.Test
 
         public static TestHttpServer CreateTestStringServer(Func<string, (int, string)> requestHandler)
         {
-            Func<string, (int, byte[])> bytesRequestHandler = url =>
+            return CreateTestStringServer((method, url) => requestHandler(url));
+        }
+
+        public static TestHttpServer CreateTestStringServer(Func<string, string, (int, string)> requestHandler)
+        {
+            Func<string, string, (int, byte[])> bytesRequestHandler = (method, url) =>
             {
-                var (statusCode, response) = requestHandler(url);
+                var (statusCode, response) = requestHandler(method, url);
                 return (statusCode, Encoding.UTF8.GetBytes(response));
             };
             return CreateTestServer(bytesRequestHandler);
@@ -170,7 +180,7 @@ namespace NuGetUpdater.Core.Test
                 return (404, Encoding.UTF8.GetBytes("{}"));
             }
 
-            var server = TestHttpServer.CreateTestServer(HttpHandler);
+            var server = CreateTestServer((method, url) => HttpHandler(url));
             return server;
         }
 

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

@@ -43,9 +43,9 @@ public class UpdateOperationBaseTests
         // assert
         var expectedReport = """
             Performed the following updates:
-                - Updated Package.A to 1.0.0 in file/a.txt
-                - Pinned Package.B at 2.0.0 in file/b.txt
-                - Updated Package.C to 3.0.0 indirectly via Package.D/4.0.0 in file/c.txt
+            - Updated Package.A to 1.0.0 in file/a.txt
+            - Pinned Package.B at 2.0.0 in file/b.txt
+            - Updated Package.C to 3.0.0 indirectly via Package.D/4.0.0 in file/c.txt
             """.Replace("\r", "");
         Assert.Equal(expectedReport, actualReport);
     }

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

@@ -382,19 +382,7 @@ public partial class UpdateWorkerTests
                     MockNuGetPackage.CreateSimplePackage("Some.Package", "9.0.1", "net8.0"),
                     MockNuGetPackage.CreateSimplePackage("Some.Package", "13.0.1", "net8.0"),
                     // necessary for the `net8.0-windows10.0.19041.0` TFM
-                    new("Microsoft.Windows.SDK.NET.Ref", "10.0.19041.54", Files:
-                    [
-                        ("data/FrameworkList.xml", Encoding.UTF8.GetBytes("""
-                            <FileList Name="Windows SDK .NET 6.0">
-                              <!-- contents omitted -->
-                            </FileList>
-                            """)),
-                        ("data/RuntimeList.xml", Encoding.UTF8.GetBytes("""
-                            <FileList Name="Windows SDK .NET 6.0" TargetFrameworkIdentifier=".NETCoreApp" TargetFrameworkVersion="6.0" FrameworkName="Microsoft.Windows.SDK.NET.Ref">
-                              <!-- contents omitted -->
-                            </FileList>
-                            """)),
-                    ]),
+                    MockNuGetPackage.WellKnownWindowsSdkRefPackage("10.0.19041.0"),
                 ],
                 // initial
                 projectContents: $"""

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Utilities/EOLHandlingTests.cs

@@ -4,20 +4,234 @@ using Xunit;
 
 using static NuGetUpdater.Core.Utilities.EOLHandling;
 
-namespace NuGetUpdater.Core.Test.Utilities
+namespace NuGetUpdater.Core.Test.Utilities;
+
+public class EOLHandlingTests
 {
-    public class EOLHandlingTests
+    [Theory]
+    [InlineData(EOLType.LF, "\n")]
+    [InlineData(EOLType.CR, "\r")]
+    [InlineData(EOLType.CRLF, "\r\n")]
+    public void ValidateEOLNormalizesFromLF(EOLType eolType, string literal)
+    {
+        var teststring = "this\ris\na\r\nstring\rwith\nmixed\r\nline\rendings\n.";
+        var changed = teststring.SetEOL(eolType);
+        var lineEndings = Regex.Split(changed, "\\S+");
+        Assert.All(lineEndings, lineEnding => lineEnding.Equals(literal));
+    }
+
+    [Theory]
+    [MemberData(nameof(GetPredominantEOLTestData))]
+    public void GetPredominantEOL(string fileContent, EOLType expectedEOL)
+    {
+        var actualEOL = fileContent.GetPredominantEOL();
+        Assert.Equal(expectedEOL, actualEOL);
+    }
+
+    [Theory]
+    [MemberData(nameof(SetEOLTestData))]
+    public void SetEOL(string currentFileContent, EOLType desiredEOL, string expectedFileContent)
+    {
+        var actualFileContent = currentFileContent.SetEOL(desiredEOL);
+        Assert.Equal(expectedFileContent, actualFileContent);
+    }
+
+    public static IEnumerable<object[]> GetPredominantEOLTestData()
     {
-        [Theory]
-        [InlineData(EOLType.LF, "\n")]
-        [InlineData(EOLType.CR, "\r")]
-        [InlineData(EOLType.CRLF, "\r\n")]
-        public void ValidateEOLNormalizesFromLF(EOLType eolType, string literal)
-        {
-            var teststring = "this\ris\na\r\nstring\rwith\nmixed\r\nline\rendings\n.";
-            var changed = teststring.SetEOL(eolType);
-            var lineEndings = Regex.Split(changed, "\\S+");
-            Assert.All(lineEndings, lineEnding => lineEnding.Equals(literal));
-        }
+        // purely CR
+        yield return
+        [
+            // fileContent
+            string.Concat(
+            "line1\r",
+            "line2\r",
+            "line3\r"
+        ),
+        // expectedEOL
+        EOLType.CR
+        ];
+
+        // purely LF
+        yield return
+        [
+            // fileContent
+            string.Concat(
+            "line1\n",
+            "line2\n",
+            "line3\n"
+        ),
+        // expectedEOL
+        EOLType.LF
+        ];
+
+        // purely CRLF
+        yield return
+        [
+            // fileContent
+            string.Concat(
+            "line1\r\n",
+            "line2\r\n",
+            "line3\r\n"
+        ),
+        // expectedEOL
+        EOLType.CRLF
+        ];
+
+        // mostly CR
+        yield return
+        [
+            // fileContent
+            string.Concat(
+            "line1\r",
+            "line2\n",
+            "line3\r"
+        ),
+        // expectedEOL
+        EOLType.CR
+        ];
+
+        // mostly LF
+        yield return
+        [
+            // fileContent
+            string.Concat(
+            "line1\n",
+            "line2\r",
+            "line3\n"
+        ),
+        // expectedEOL
+        EOLType.LF
+        ];
+
+        // mostly CRLF
+        yield return
+        [
+            // fileContent
+            string.Concat(
+            "line1\r\n",
+            "line2\n",
+            "line3\r",
+            "line4\r\n"
+        ),
+        // expectedEOL
+        EOLType.CRLF
+        ];
+    }
+
+    public static IEnumerable<object[]> SetEOLTestData()
+    {
+        // CR to CR
+        yield return
+        [
+            // currentFileContent
+            string.Concat(
+            "line1\r",
+            "line2\r",
+            "line3\r"
+        ),
+        // desiredEOL
+        EOLType.CR,
+        // expectedFileContent
+        string.Concat(
+            "line1\r",
+            "line2\r",
+            "line3\r"
+        )
+        ];
+
+        // LF to LF
+        yield return
+        [
+            // currentFileContent
+            string.Concat(
+            "line1\n",
+            "line2\n",
+            "line3\n"
+        ),
+        // desiredEOL
+        EOLType.LF,
+        // expectedFileContent
+        string.Concat(
+            "line1\n",
+            "line2\n",
+            "line3\n"
+        )
+        ];
+
+        // CRLF to CRLF
+        yield return
+        [
+            // currentFileContent
+            string.Concat(
+            "line1\r\n",
+            "line2\r\n",
+            "line3\r\n"
+        ),
+        // desiredEOL
+        EOLType.CRLF,
+        // expectedFileContent
+        string.Concat(
+            "line1\r\n",
+            "line2\r\n",
+            "line3\r\n"
+        )
+        ];
+
+        // mixed to CR
+        yield return
+        [
+            // currentFileContent
+            string.Concat(
+            "line1\r",
+            "line2\n",
+            "line3\r\n"
+        ),
+        // desiredEOL
+        EOLType.CR,
+        // expectedFileContent
+        string.Concat(
+            "line1\r",
+            "line2\r",
+            "line3\r"
+        )
+        ];
+
+        // mixed to LF
+        yield return
+        [
+            // currentFileContent
+            string.Concat(
+            "line1\r",
+            "line2\n",
+            "line3\r\n"
+        ),
+        // desiredEOL
+        EOLType.LF,
+        // expectedFileContent
+        string.Concat(
+            "line1\n",
+            "line2\n",
+            "line3\n"
+        )
+        ];
+
+        // mixed to CRLF
+        yield return
+        [
+            // currentFileContent
+            string.Concat(
+            "line1\r",
+            "line2\n",
+            "line3\r\n"
+        ),
+        // desiredEOL
+        EOLType.CRLF,
+        // expectedFileContent
+        string.Concat(
+            "line1\r\n",
+            "line2\r\n",
+            "line3\r\n"
+        )
+        ];
     }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Utilities/LoggerTests.cs

@@ -5,7 +5,6 @@ using System.Text;
 using System.Threading.Tasks;
 
 using Xunit;
-using Xunit.Abstractions;
 using Xunit.Sdk;
 
 namespace NuGetUpdater.Core.Test.Utilities;