starred/WireMock.Net
1
0
Fork 0
mirror of https://github.com/wiremock/WireMock.Net.git synced 2026-03-29 13:52:08 +02:00
Code Issues 32 Packages Projects Releases 10 Wiki Activity

Fix some SonarCloud issues (#955)

Browse Source 
* Fixed some SonarCloud issues

* if (value.Contains('\n'))
This commit is contained in:
Stef Heyenrath
2023-06-13 19:31:04 +02:00
committed by GitHub
parent f6e35cbe2d
commit 5d0bf6f4e1
5 changed files with 176 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/WireMock.Net.OpenApiParser/Mappers/OpenApiPathsMapper.cs
View File

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

4
src/WireMock.Net.OpenApiParser/WireMockOpenApiParser.cs
View File

@@ -47,9 +47,9 @@ public class WireMockOpenApiParser : IWireMockOpenApiParser
/// <inheritdoc /> /// <inheritdoc />
[PublicAPI] [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 /> /// <inheritdoc />

2
src/WireMock.Net/Util/CSharpFormatter.cs
View File

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

18
test/WireMock.Net.Tests/Pact/PactTests.cs
View File

@@ -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] [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);
} }
} }

315
test/WireMock.Net.Tests/WireMockServer.AdminFiles.cs
View File

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