dependabot-nuget 0.309.0 → 0.310.0

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/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"
+        )
+        ];
     }
 }