dependabot-nuget 0.308.0 → 0.310.0

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

@@ -16,14 +16,13 @@ internal class TestDiscoveryWorker : IDiscoveryWorker
         return _getResult((repoRootPath, workspacePath));
     }
 
-    public static TestDiscoveryWorker FromResults(params (string RepoRootPath, string WorkspacePath, WorkspaceDiscoveryResult Result)[] results)
+    public static TestDiscoveryWorker FromResults(params (string WorkspacePath, WorkspaceDiscoveryResult Result)[] results)
     {
-        return new TestDiscoveryWorker(((string RepoRootPath, string WorkspacePath) input) =>
+        return new TestDiscoveryWorker(((string _RepoRootPath, string WorkspacePath) input) =>
         {
             foreach (var set in results)
             {
-                if (set.RepoRootPath == input.RepoRootPath &&
-                    set.WorkspacePath == input.WorkspacePath)
+                if (set.WorkspacePath == input.WorkspacePath)
                 {
                     return Task.FromResult(set.Result);
                 }

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/SpecialFilePatcherTests.cs

@@ -31,6 +31,8 @@ public class SpecialFilePatcherTests
 
     public static IEnumerable<object[]> SpecialImportsConditionPatcherTestData()
     {
+        // magic file names
+
         // one-off test to verify namespaces don't interfere
         yield return
         [
@@ -95,5 +97,22 @@ public class SpecialFilePatcherTests
             </Project>
             """
         ];
+
+        // magic property segments
+        yield return
+        [
+            // fileContent
+            """
+            <Project>
+              <Import Project="$(PkgSome_Package)\build\Some.Package.targets" />
+            </Project>
+            """,
+            // expectedPatchedContent
+            """
+            <Project>
+              <Import Project="$(PkgSome_Package)\build\Some.Package.targets" Condition="false" />
+            </Project>
+            """
+        ];
     }
 }

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

@@ -0,0 +1,66 @@
+using NuGetUpdater.Core.Utilities;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Utilities;
+
+public class BOMHandlingTests
+{
+    [Theory]
+    [MemberData(nameof(HasBOMTestData))]
+    public void HasBOM(byte[] content, bool expectedHasBOM)
+    {
+        var actualHasBOM = content.HasBOM();
+        Assert.Equal(expectedHasBOM, actualHasBOM);
+    }
+
+    [Theory]
+    [MemberData(nameof(SetBOMTestData))]
+    public void SetBOM(string content, bool setBOM, byte[] expectedBytes)
+    {
+        var actualBytes = content.SetBOM(setBOM);
+        AssertEx.Equal(expectedBytes, actualBytes);
+    }
+
+    public static IEnumerable<object[]> HasBOMTestData()
+    {
+        yield return
+        [
+            // content
+            new byte[] { 0xEF, 0xBB, 0xBF, (byte)'A' },
+            // expectedHasBOM
+            true
+        ];
+
+        yield return
+        [
+            // content
+            new byte[] { (byte)'A' },
+            // expectedHasBOM
+            false
+        ];
+    }
+
+    public static IEnumerable<object[]> SetBOMTestData()
+    {
+        yield return
+        [
+            // content
+            "A",
+            // setBOM
+            true,
+            // expectedBytes
+            new byte[] { 0xEF, 0xBB, 0xBF, (byte)'A' }
+        ];
+
+        yield return
+        [
+            // content
+            "A",
+            // setBOM
+            false,
+            // expectedBytes
+            new byte[] { (byte)'A' }
+        ];
+    }
+}

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