Fix some SonarCloud issues (#955)

* Fixed some SonarCloud issues

* if (value.Contains('\n'))

src/WireMock.Net.OpenApiParser/Mappers/OpenApiPathsMapper.cs

@@ -320,14 +320,14 @@ internal class OpenApiPathsMapper
         var mappedHeaders = headers?.ToDictionary(
             item => item.Key,
             _ => GetExampleMatcherModel(null, _settings.HeaderPatternToUse).Pattern!
-        );
+        ) ?? new Dictionary<string, object>();
 
         if (!string.IsNullOrEmpty(responseContentType))
         {
             mappedHeaders.TryAdd(HeaderContentType, responseContentType!);
         }
 
-        return mappedHeaders?.Keys.Any() == true ? mappedHeaders : null;
+        return mappedHeaders.Keys.Any() ? mappedHeaders : null;
     }
 
     private IList<ParamModel>? MapQueryParameters(IEnumerable<OpenApiParameter> queryParameters)

src/WireMock.Net.OpenApiParser/WireMockOpenApiParser.cs

@@ -47,9 +47,9 @@ public class WireMockOpenApiParser : IWireMockOpenApiParser
 
     /// <inheritdoc />
     [PublicAPI]
-    public IReadOnlyList<MappingModel> FromDocument(OpenApiDocument openApiDocument, WireMockOpenApiParserSettings? settings = null)
+    public IReadOnlyList<MappingModel> FromDocument(OpenApiDocument document, WireMockOpenApiParserSettings? settings = null)
     {
-        return new OpenApiPathsMapper(settings ?? new WireMockOpenApiParserSettings()).ToMappingModels(openApiDocument.Paths, openApiDocument.Servers);
+        return new OpenApiPathsMapper(settings ?? new WireMockOpenApiParserSettings()).ToMappingModels(document.Paths, document.Servers);
     }
 
     /// <inheritdoc  />

src/WireMock.Net/Util/CSharpFormatter.cs

@@ -138,7 +138,7 @@ internal static class CSharpFormatter
             return "\"\"";
         }
 
-        if (value.Contains("\n"))
+        if (value.Contains('\n'))
         {
             var escapedValue = value?.Replace("\"", "\"\"") ?? string.Empty;
             return $"@\"{escapedValue}\"";

test/WireMock.Net.Tests/Pact/PactTests.cs

@@ -42,7 +42,14 @@ public class PactTests
                     })
             );
 
-        server.SavePact(Path.Combine("../../../", "Pact", "files"), "pact-get.json");
+        var folder = Path.Combine("../../../", "Pact", "files");
+        var file = "pact-get.json";
+
+        // Act
+        server.SavePact(folder, file);
+
+        // Assert
+        File.ReadAllBytes(Path.Combine(folder, file)).Length.Should().BeGreaterThan(1);
     }
 
     [Fact]
@@ -201,6 +208,13 @@ public class PactTests
                     })
             );
 
-        server.SavePact(Path.Combine("../../../", "Pact", "files"), "pact-multiple.json");
+        var folder = Path.Combine("../../../", "Pact", "files");
+        var file = "pact-multiple.json";
+
+        // Act
+        server.SavePact(folder, file);
+
+        // Assert
+        File.ReadAllBytes(Path.Combine(folder, file)).Length.Should().BeGreaterThan(1);
     }
 }

test/WireMock.Net.Tests/WireMockServer.AdminFiles.cs

@@ -1,215 +1,210 @@
-using Moq;
-using NFluent;
 using System.IO;
-using System.Linq;
 using System.Net;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Text;
 using System.Threading.Tasks;
+using FluentAssertions;
+using Moq;
 using WireMock.Handlers;
 using WireMock.Server;
 using WireMock.Settings;
 using Xunit;
 
-namespace WireMock.Net.Tests
+namespace WireMock.Net.Tests;
+
+public class WireMockServerAdminFilesTests
 {
-    public class WireMockServerAdminFilesTests
+    private readonly HttpClient _client = new HttpClient();
+
+    [Fact]
+    public async Task WireMockServer_Admin_Files_Post_Ascii()
     {
-        private readonly HttpClient _client = new HttpClient();
+        // Arrange
+        var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+        filesystemHandlerMock.Setup(fs => fs.GetMappingFolder()).Returns("__admin/mappings");
+        filesystemHandlerMock.Setup(fs => fs.FolderExists(It.IsAny<string>())).Returns(true);
+        filesystemHandlerMock.Setup(fs => fs.WriteFile(It.IsAny<string>(), It.IsAny<byte[]>()));
 
-        [Fact]
-        public async Task WireMockServer_Admin_Files_Post_Ascii()
+        var server = WireMockServer.Start(new WireMockServerSettings
         {
-            // Arrange
-            var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
-            filesystemHandlerMock.Setup(fs => fs.GetMappingFolder()).Returns("__admin/mappings");
-            filesystemHandlerMock.Setup(fs => fs.FolderExists(It.IsAny<string>())).Returns(true);
-            filesystemHandlerMock.Setup(fs => fs.WriteFile(It.IsAny<string>(), It.IsAny<byte[]>()));
+            UseSSL = false,
+            StartAdminInterface = true,
+            FileSystemHandler = filesystemHandlerMock.Object
+        });
 
-            var server = WireMockServer.Start(new WireMockServerSettings
-            {
-                UseSSL = false,
-                StartAdminInterface = true,
-                FileSystemHandler = filesystemHandlerMock.Object
-            });
+        var multipartFormDataContent = new MultipartFormDataContent();
+        multipartFormDataContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
+        multipartFormDataContent.Add(new StreamContent(new MemoryStream(Encoding.ASCII.GetBytes("Here's a string."))));
 
-            var multipartFormDataContent = new MultipartFormDataContent();
-            multipartFormDataContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
-            multipartFormDataContent.Add(new StreamContent(new MemoryStream(Encoding.ASCII.GetBytes("Here's a string."))));
+        // Act
+        var httpResponseMessage = await _client.PostAsync("http://localhost:" + server.Ports[0] + "/__admin/files/filename.txt", multipartFormDataContent).ConfigureAwait(false);
 
-            // Act
-            var httpResponseMessage = await _client.PostAsync("http://localhost:" + server.Ports[0] + "/__admin/files/filename.txt", multipartFormDataContent).ConfigureAwait(false);
+        // Assert
+        httpResponseMessage.StatusCode.Should().Be(HttpStatusCode.OK);
 
-            // Assert
-            Check.That(httpResponseMessage.StatusCode).Equals(HttpStatusCode.OK);
-            Check.That(server.LogEntries.Count().Equals(1));
+        // Verify
+        filesystemHandlerMock.Verify(fs => fs.GetMappingFolder(), Times.Once);
+        filesystemHandlerMock.Verify(fs => fs.FolderExists(It.IsAny<string>()), Times.Once);
+        filesystemHandlerMock.Verify(fs => fs.WriteFile(It.Is<string>(p => p == "filename.txt"), It.IsAny<byte[]>()), Times.Once);
+        filesystemHandlerMock.VerifyNoOtherCalls();
+    }
 
-            // Verify
-            filesystemHandlerMock.Verify(fs => fs.GetMappingFolder(), Times.Once);
-            filesystemHandlerMock.Verify(fs => fs.FolderExists(It.IsAny<string>()), Times.Once);
-            filesystemHandlerMock.Verify(fs => fs.WriteFile(It.Is<string>(p => p == "filename.txt"), It.IsAny<byte[]>()), Times.Once);
-            filesystemHandlerMock.VerifyNoOtherCalls();
-        }
+    [Fact]
+    public async Task WireMockServer_Admin_Files_Post_MappingFolderDoesNotExistsButWillBeCreated()
+    {
+        // Arrange
+        var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+        filesystemHandlerMock.Setup(fs => fs.GetMappingFolder()).Returns("x");
+        filesystemHandlerMock.Setup(fs => fs.CreateFolder(It.IsAny<string>()));
+        filesystemHandlerMock.Setup(fs => fs.FolderExists(It.IsAny<string>())).Returns(false);
+        filesystemHandlerMock.Setup(fs => fs.WriteFile(It.IsAny<string>(), It.IsAny<byte[]>()));
 
-        [Fact]
-        public async Task WireMockServer_Admin_Files_Post_MappingFolderDoesNotExistsButWillBeCreated()
+        var server = WireMockServer.Start(new WireMockServerSettings
         {
-            // Arrange
-            var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
-            filesystemHandlerMock.Setup(fs => fs.GetMappingFolder()).Returns("x");
-            filesystemHandlerMock.Setup(fs => fs.CreateFolder(It.IsAny<string>()));
-            filesystemHandlerMock.Setup(fs => fs.FolderExists(It.IsAny<string>())).Returns(false);
-            filesystemHandlerMock.Setup(fs => fs.WriteFile(It.IsAny<string>(), It.IsAny<byte[]>()));
+            UseSSL = false,
+            StartAdminInterface = true,
+            FileSystemHandler = filesystemHandlerMock.Object
+        });
 
-            var server = WireMockServer.Start(new WireMockServerSettings
-            {
-                UseSSL = false,
-                StartAdminInterface = true,
-                FileSystemHandler = filesystemHandlerMock.Object
-            });
+        var multipartFormDataContent = new MultipartFormDataContent();
+        multipartFormDataContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
+        multipartFormDataContent.Add(new StreamContent(new MemoryStream(Encoding.ASCII.GetBytes("Here's a string."))));
 
-            var multipartFormDataContent = new MultipartFormDataContent();
-            multipartFormDataContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
-            multipartFormDataContent.Add(new StreamContent(new MemoryStream(Encoding.ASCII.GetBytes("Here's a string."))));
+        // Act
+        var httpResponseMessage = await _client.PostAsync("http://localhost:" + server.Ports[0] + "/__admin/files/filename.txt", multipartFormDataContent).ConfigureAwait(false);
 
-            // Act
-            var httpResponseMessage = await _client.PostAsync("http://localhost:" + server.Ports[0] + "/__admin/files/filename.txt", multipartFormDataContent).ConfigureAwait(false);
+        // Assert
+        httpResponseMessage.StatusCode.Should().Be(HttpStatusCode.OK);
 
-            // Assert
-            Check.That(httpResponseMessage.StatusCode).Equals(HttpStatusCode.OK);
+        // Verify
+        filesystemHandlerMock.Verify(fs => fs.GetMappingFolder(), Times.Once);
+        filesystemHandlerMock.Verify(fs => fs.FolderExists(It.IsAny<string>()), Times.Once);
+        filesystemHandlerMock.Verify(fs => fs.CreateFolder(It.Is<string>(p => p == "x")), Times.Once);
+        filesystemHandlerMock.Verify(fs => fs.WriteFile(It.Is<string>(p => p == "filename.txt"), It.IsAny<byte[]>()), Times.Once);
+        filesystemHandlerMock.VerifyNoOtherCalls();
+    }
 
-            // Verify
-            filesystemHandlerMock.Verify(fs => fs.GetMappingFolder(), Times.Once);
-            filesystemHandlerMock.Verify(fs => fs.FolderExists(It.IsAny<string>()), Times.Once);
-            filesystemHandlerMock.Verify(fs => fs.CreateFolder(It.Is<string>(p => p == "x")), Times.Once);
-            filesystemHandlerMock.Verify(fs => fs.WriteFile(It.Is<string>(p => p == "filename.txt"), It.IsAny<byte[]>()), Times.Once);
-            filesystemHandlerMock.VerifyNoOtherCalls();
-        }
+    [Fact]
+    public async Task WireMockServer_Admin_Files_GetAscii()
+    {
+        // Arrange
+        var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+        filesystemHandlerMock.Setup(fs => fs.FileExists(It.IsAny<string>())).Returns(true);
+        filesystemHandlerMock.Setup(fs => fs.ReadFile(It.IsAny<string>())).Returns(Encoding.ASCII.GetBytes("Here's a string."));
 
-        [Fact]
-        public async Task WireMockServer_Admin_Files_GetAscii()
+        var server = WireMockServer.Start(new WireMockServerSettings
         {
-            // Arrange
-            var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
-            filesystemHandlerMock.Setup(fs => fs.FileExists(It.IsAny<string>())).Returns(true);
-            filesystemHandlerMock.Setup(fs => fs.ReadFile(It.IsAny<string>())).Returns(Encoding.ASCII.GetBytes("Here's a string."));
+            UseSSL = false,
+            StartAdminInterface = true,
+            FileSystemHandler = filesystemHandlerMock.Object
+        });
 
-            var server = WireMockServer.Start(new WireMockServerSettings
-            {
-                UseSSL = false,
-                StartAdminInterface = true,
-                FileSystemHandler = filesystemHandlerMock.Object
-            });
+        var multipartFormDataContent = new MultipartFormDataContent();
+        multipartFormDataContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
+        multipartFormDataContent.Add(new StreamContent(new MemoryStream()));
 
-            var multipartFormDataContent = new MultipartFormDataContent();
-            multipartFormDataContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
-            multipartFormDataContent.Add(new StreamContent(new MemoryStream()));
+        // Act
+        var httpResponseMessageGet = await _client.GetAsync("http://localhost:" + server.Ports[0] + "/__admin/files/filename.txt").ConfigureAwait(false);
 
-            // Act
-            var httpResponseMessageGet = await _client.GetAsync("http://localhost:" + server.Ports[0] + "/__admin/files/filename.txt").ConfigureAwait(false);
+        // Assert
+        httpResponseMessageGet.StatusCode.Should().Be(HttpStatusCode.OK);
 
-            // Assert
-            Check.That(httpResponseMessageGet.StatusCode).Equals(HttpStatusCode.OK);
+        var result = await httpResponseMessageGet.Content.ReadAsStringAsync().ConfigureAwait(false);
+        result.Should().Be("Here's a string.");
 
-            Check.That(httpResponseMessageGet.Content.ReadAsStringAsync().Result).Equals("Here's a string.");
+        // Verify
+        filesystemHandlerMock.Verify(fs => fs.ReadFile(It.Is<string>(p => p == "filename.txt")), Times.Once);
+        filesystemHandlerMock.Verify(fs => fs.FileExists(It.Is<string>(p => p == "filename.txt")), Times.Once);
+        filesystemHandlerMock.VerifyNoOtherCalls();
+    }
 
-            Check.That(server.LogEntries.Count().Equals(2));
+    [Fact]
+    public async Task WireMockServer_Admin_Files_GetUTF16()
+    {
+        // Arrange
+        byte[] symbol = Encoding.UTF32.GetBytes(char.ConvertFromUtf32(0x1D161));
+        var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+        filesystemHandlerMock.Setup(fs => fs.FileExists(It.IsAny<string>())).Returns(true);
+        filesystemHandlerMock.Setup(fs => fs.ReadFile(It.IsAny<string>())).Returns(symbol);
 
-            // Verify
-            filesystemHandlerMock.Verify(fs => fs.ReadFile(It.Is<string>(p => p == "filename.txt")), Times.Once);
-            filesystemHandlerMock.Verify(fs => fs.FileExists(It.Is<string>(p => p == "filename.txt")), Times.Once);
-            filesystemHandlerMock.VerifyNoOtherCalls();
-        }
-
-        [Fact]
-        public async Task WireMockServer_Admin_Files_GetUTF16()
+        var server = WireMockServer.Start(new WireMockServerSettings
         {
-            // Arrange
-            byte[] symbol = Encoding.UTF32.GetBytes(char.ConvertFromUtf32(0x1D161));
-            var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
-            filesystemHandlerMock.Setup(fs => fs.FileExists(It.IsAny<string>())).Returns(true);
-            filesystemHandlerMock.Setup(fs => fs.ReadFile(It.IsAny<string>())).Returns(symbol);
+            UseSSL = false,
+            StartAdminInterface = true,
+            FileSystemHandler = filesystemHandlerMock.Object
+        });
 
-            var server = WireMockServer.Start(new WireMockServerSettings
-            {
-                UseSSL = false,
-                StartAdminInterface = true,
-                FileSystemHandler = filesystemHandlerMock.Object
-            });
+        var multipartFormDataContent = new MultipartFormDataContent();
+        multipartFormDataContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
+        multipartFormDataContent.Add(new StreamContent(new MemoryStream()));
 
-            var multipartFormDataContent = new MultipartFormDataContent();
-            multipartFormDataContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
-            multipartFormDataContent.Add(new StreamContent(new MemoryStream()));
+        // Act
+        var httpResponseMessageGet = await _client.GetAsync("http://localhost:" + server.Ports[0] + "/__admin/files/filename.bin").ConfigureAwait(false);
 
-            // Act
-            var httpResponseMessageGet = await _client.GetAsync("http://localhost:" + server.Ports[0] + "/__admin/files/filename.bin").ConfigureAwait(false);
+        // Assert
+        httpResponseMessageGet.StatusCode.Should().Be(HttpStatusCode.OK);
 
-            // Assert
-            Check.That(httpResponseMessageGet.StatusCode).Equals(HttpStatusCode.OK);
-            Check.That(httpResponseMessageGet.Content.ReadAsByteArrayAsync().Result).Equals(symbol);
-            Check.That(server.LogEntries.Count().Equals(2));
+        var result = await httpResponseMessageGet.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
+        result.Should().BeEquivalentTo(symbol);
 
-            // Verify
-            filesystemHandlerMock.Verify(fs => fs.ReadFile(It.Is<string>(p => p == "filename.bin")), Times.Once);
-            filesystemHandlerMock.Verify(fs => fs.FileExists(It.Is<string>(p => p == "filename.bin")), Times.Once);
-            filesystemHandlerMock.VerifyNoOtherCalls();
-        }
+        // Verify
+        filesystemHandlerMock.Verify(fs => fs.ReadFile(It.Is<string>(p => p == "filename.bin")), Times.Once);
+        filesystemHandlerMock.Verify(fs => fs.FileExists(It.Is<string>(p => p == "filename.bin")), Times.Once);
+        filesystemHandlerMock.VerifyNoOtherCalls();
+    }
 
-        [Fact]
-        public async Task WireMockServer_Admin_Files_Head()
+    [Fact]
+    public async Task WireMockServer_Admin_Files_Head()
+    {
+        // Arrange
+        var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+        filesystemHandlerMock.Setup(fs => fs.FileExists(It.IsAny<string>())).Returns(true);
+
+        var server = WireMockServer.Start(new WireMockServerSettings
         {
-            // Arrange
-            var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
-            filesystemHandlerMock.Setup(fs => fs.FileExists(It.IsAny<string>())).Returns(true);
+            UseSSL = false,
+            StartAdminInterface = true,
+            FileSystemHandler = filesystemHandlerMock.Object
+        });
 
-            var server = WireMockServer.Start(new WireMockServerSettings
-            {
-                UseSSL = false,
-                StartAdminInterface = true,
-                FileSystemHandler = filesystemHandlerMock.Object
-            });
+        // Act
+        var requestUri = "http://localhost:" + server.Ports[0] + "/__admin/files/filename.txt";
+        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Head, requestUri);
+        var httpResponseMessage = await _client.SendAsync(httpRequestMessage).ConfigureAwait(false);
 
-            // Act
-            var requestUri = "http://localhost:" + server.Ports[0] + "/__admin/files/filename.txt";
-            var httpRequestMessage = new HttpRequestMessage(HttpMethod.Head, requestUri);
-            var httpResponseMessage = await _client.SendAsync(httpRequestMessage).ConfigureAwait(false);
+        // Assert
+        httpResponseMessage.StatusCode.Should().Be(HttpStatusCode.NoContent);
 
-            // Assert
-            Check.That(httpResponseMessage.StatusCode).Equals(HttpStatusCode.NoContent);
-            Check.That(server.LogEntries.Count().Equals(1));
+        // Verify
+        filesystemHandlerMock.Verify(fs => fs.FileExists(It.IsAny<string>()), Times.Once);
+        filesystemHandlerMock.VerifyNoOtherCalls();
+    }
 
-            // Verify
-            filesystemHandlerMock.Verify(fs => fs.FileExists(It.IsAny<string>()), Times.Once);
-            filesystemHandlerMock.VerifyNoOtherCalls();
-        }
+    [Fact]
+    public async Task WireMockServer_Admin_Files_Head_FileDoesNotExistsReturns404()
+    {
+        // Arrange
+        var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+        filesystemHandlerMock.Setup(fs => fs.FileExists(It.IsAny<string>())).Returns(false);
 
-        [Fact]
-        public async Task WireMockServer_Admin_Files_Head_FileDoesNotExistsReturns404()
+        var server = WireMockServer.Start(new WireMockServerSettings
         {
-            // Arrange
-            var filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
-            filesystemHandlerMock.Setup(fs => fs.FileExists(It.IsAny<string>())).Returns(false);
+            UseSSL = false,
+            StartAdminInterface = true,
+            FileSystemHandler = filesystemHandlerMock.Object
+        });
 
-            var server = WireMockServer.Start(new WireMockServerSettings
-            {
-                UseSSL = false,
-                StartAdminInterface = true,
-                FileSystemHandler = filesystemHandlerMock.Object
-            });
+        // Act
+        var requestUri = "http://localhost:" + server.Ports[0] + "/__admin/files/filename.txt";
+        var httpRequestMessage = new HttpRequestMessage(HttpMethod.Head, requestUri);
+        var httpResponseMessage = await _client.SendAsync(httpRequestMessage).ConfigureAwait(false);
 
-            // Act
-            var requestUri = "http://localhost:" + server.Ports[0] + "/__admin/files/filename.txt";
-            var httpRequestMessage = new HttpRequestMessage(HttpMethod.Head, requestUri);
-            var httpResponseMessage = await _client.SendAsync(httpRequestMessage).ConfigureAwait(false);
+        // Assert
+        httpResponseMessage.StatusCode.Should().Be(HttpStatusCode.NotFound);
 
-            // Assert
-            Check.That(httpResponseMessage.StatusCode).Equals(HttpStatusCode.NotFound);
-            Check.That(server.LogEntries.Count().Equals(1));
-
-            // Verify
-            filesystemHandlerMock.Verify(fs => fs.FileExists(It.IsAny<string>()), Times.Once);
-            filesystemHandlerMock.VerifyNoOtherCalls();
-        }
+        // Verify
+        filesystemHandlerMock.Verify(fs => fs.FileExists(It.IsAny<string>()), Times.Once);
+        filesystemHandlerMock.VerifyNoOtherCalls();
     }
 }