starred/WireMock.Net
1
0
Fork 0
mirror of https://github.com/wiremock/WireMock.Net.git synced 2026-03-21 00:50:24 +01:00
Code Issues 32 Packages Projects Releases 10 Wiki Activity

WithProxy() should save the new mapping (#600)

Browse Source 
* WithProxy should save the new mapping

* fix ut

* .
This commit is contained in:
Stef Heyenrath
2021-03-31 18:17:27 +02:00
committed by GitHub
parent 2ad060bbd4
commit 8140b37095
34 changed files with 1343 additions and 1356 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
test/WireMock.Net.Tests/Owin/WireMockMiddlewareTests.cs
View File

@@ -13,7 +13,6 @@ using WireMock.Matchers;
using System.Collections.Generic;
using WireMock.Admin.Mappings;
using WireMock.Admin.Requests;
using WireMock.ResponseProviders;
using WireMock.Settings;
using FluentAssertions;
using WireMock.Handlers;
@@ -177,7 +176,8 @@ namespace WireMock.Net.Tests.Owin
_mappingMock.SetupGet(m => m.Provider).Returns(responseBuilder);
_mappingMock.SetupGet(m => m.Settings).Returns(settings);
_mappingMock.Setup(m => m.ProvideResponseAsync(It.IsAny<RequestMessage>())).ReturnsAsync(new ResponseMessage());
var newMappingFromProxy = new Mapping(Guid.NewGuid(), "", null, settings, Request.Create(), Response.Create(), 0, null, null, null, null, null);
_mappingMock.Setup(m => m.ProvideResponseAsync(It.IsAny<RequestMessage>())).ReturnsAsync((new ResponseMessage(), newMappingFromProxy));
var requestBuilder = Request.Create().UsingAnyMethod();
_mappingMock.SetupGet(m => m.RequestMatcher).Returns(requestBuilder);
@@ -230,7 +230,8 @@ namespace WireMock.Net.Tests.Owin
_mappingMock.SetupGet(m => m.Provider).Returns(responseBuilder);
_mappingMock.SetupGet(m => m.Settings).Returns(settings);
_mappingMock.Setup(m => m.ProvideResponseAsync(It.IsAny<RequestMessage>())).ReturnsAsync(new ResponseMessage());
var newMappingFromProxy = new Mapping(Guid.NewGuid(), "", null, settings, Request.Create(), Response.Create(), 0, null, null, null, null, null);
_mappingMock.Setup(m => m.ProvideResponseAsync(It.IsAny<RequestMessage>())).ReturnsAsync((new ResponseMessage(), newMappingFromProxy));
var requestBuilder = Request.Create().UsingAnyMethod();
_mappingMock.SetupGet(m => m.RequestMatcher).Returns(requestBuilder);

6
test/WireMock.Net.Tests/ResponseBuilders/ResponseCreateTests.cs
View File

@@ -18,13 +18,13 @@ namespace WireMock.Net.Tests.ResponseBuilders
var responseMessage = new ResponseMessage { StatusCode = 500 };
var request = new RequestMessage(new UrlDetails("http://localhost"), "GET", "::1");
var response = Response.Create(() => responseMessage);
var responseBuilder = Response.Create(() => responseMessage);
// Act
var providedResponse = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(providedResponse).Equals(responseMessage);
Check.That(response.Message).Equals(responseMessage);
}
}
}

162
test/WireMock.Net.Tests/ResponseBuilders/ResponseWithBodyTests.cs
View File

@@ -40,15 +40,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, body);
var response = Response.Create().WithBody(new byte[] { 48, 49 }, BodyDestinationFormat.String, Encoding.ASCII);
var responseBuilder = Response.Create().WithBody(new byte[] { 48, 49 }, BodyDestinationFormat.String, Encoding.ASCII);
// act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// then
Check.That(responseMessage.BodyData.BodyAsString).Equals("01");
Check.That(responseMessage.BodyData.BodyAsBytes).IsNull();
Check.That(responseMessage.BodyData.Encoding).Equals(Encoding.ASCII);
Check.That(response.Message.BodyData.BodyAsString).Equals("01");
Check.That(response.Message.BodyData.BodyAsBytes).IsNull();
Check.That(response.Message.BodyData.Encoding).Equals(Encoding.ASCII);
}
[Fact]
@@ -62,15 +62,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, body);
var response = Response.Create().WithBody(new byte[] { 48, 49 }, BodyDestinationFormat.SameAsSource, Encoding.ASCII);
var responseBuilder = Response.Create().WithBody(new byte[] { 48, 49 }, BodyDestinationFormat.SameAsSource, Encoding.ASCII);
// act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// then
Check.That(responseMessage.BodyData.BodyAsBytes).ContainsExactly(new byte[] { 48, 49 });
Check.That(responseMessage.BodyData.BodyAsString).IsNull();
Check.That(responseMessage.BodyData.Encoding).IsNull();
Check.That(response.Message.BodyData.BodyAsBytes).ContainsExactly(new byte[] { 48, 49 });
Check.That(response.Message.BodyData.BodyAsString).IsNull();
Check.That(response.Message.BodyData.Encoding).IsNull();
}
[Fact]
@@ -84,14 +84,14 @@ namespace WireMock.Net.Tests.ResponseBuilders
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, body);
var response = Response.Create().WithBody("test", null, Encoding.ASCII);
var responseBuilder = Response.Create().WithBody("test", null, Encoding.ASCII);
// act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// then
Check.That(responseMessage.BodyData.BodyAsString).Equals("test");
Check.That(responseMessage.BodyData.Encoding).Equals(Encoding.ASCII);
Check.That(response.Message.BodyData.BodyAsString).Equals("test");
Check.That(response.Message.BodyData.Encoding).Equals(Encoding.ASCII);
}
[Fact]
@@ -106,14 +106,14 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, body);
object x = new { value = "test" };
var response = Response.Create().WithBodyAsJson(x, Encoding.ASCII);
var responseBuilder = Response.Create().WithBodyAsJson(x, Encoding.ASCII);
// act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// then
Check.That(responseMessage.BodyData.BodyAsJson).Equals(x);
Check.That(responseMessage.BodyData.Encoding).Equals(Encoding.ASCII);
Check.That(response.Message.BodyData.BodyAsJson).Equals(x);
Check.That(response.Message.BodyData.Encoding).Equals(Encoding.ASCII);
}
[Fact]
@@ -128,14 +128,14 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, body);
object x = new { message = "Hello" };
var response = Response.Create().WithBodyAsJson(x, true);
var responseBuilder = Response.Create().WithBodyAsJson(x, true);
// act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// then
Check.That(responseMessage.BodyData.BodyAsJson).Equals(x);
Check.That(responseMessage.BodyData.BodyAsJsonIndented).IsEqualTo(true);
Check.That(response.Message.BodyData.BodyAsJson).Equals(x);
Check.That(response.Message.BodyData.BodyAsJsonIndented).IsEqualTo(true);
}
[Fact]
@@ -144,16 +144,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost"), "GET", ClientIp);
var response = Response.Create().WithBody("r", BodyDestinationFormat.SameAsSource, Encoding.ASCII);
var responseBuilder = Response.Create().WithBody("r", BodyDestinationFormat.SameAsSource, Encoding.ASCII);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsBytes).IsNull();
Check.That(responseMessage.BodyData.BodyAsJson).IsNull();
Check.That(responseMessage.BodyData.BodyAsString).Equals("r");
Check.That(responseMessage.BodyData.Encoding).Equals(Encoding.ASCII);
Check.That(response.Message.BodyData.BodyAsBytes).IsNull();
Check.That(response.Message.BodyData.BodyAsJson).IsNull();
Check.That(response.Message.BodyData.BodyAsString).Equals("r");
Check.That(response.Message.BodyData.Encoding).Equals(Encoding.ASCII);
}
[Fact]
@@ -162,16 +162,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost"), "GET", ClientIp);
var response = Response.Create().WithBody("r", BodyDestinationFormat.Bytes, Encoding.ASCII);
var responseBuilder = Response.Create().WithBody("r", BodyDestinationFormat.Bytes, Encoding.ASCII);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).IsNull();
Check.That(responseMessage.BodyData.BodyAsJson).IsNull();
Check.That(responseMessage.BodyData.BodyAsBytes).IsNotNull();
Check.That(responseMessage.BodyData.Encoding).Equals(Encoding.ASCII);
Check.That(response.Message.BodyData.BodyAsString).IsNull();
Check.That(response.Message.BodyData.BodyAsJson).IsNull();
Check.That(response.Message.BodyData.BodyAsBytes).IsNotNull();
Check.That(response.Message.BodyData.Encoding).Equals(Encoding.ASCII);
}
[Fact]
@@ -180,16 +180,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost"), "GET", ClientIp);
var response = Response.Create().WithBody("{ \"value\": 42 }", BodyDestinationFormat.Json, Encoding.ASCII);
var responseBuilder = Response.Create().WithBody("{ \"value\": 42 }", BodyDestinationFormat.Json, Encoding.ASCII);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).IsNull();
Check.That(responseMessage.BodyData.BodyAsBytes).IsNull();
Check.That(((dynamic)responseMessage.BodyData.BodyAsJson).value).Equals(42);
Check.That(responseMessage.BodyData.Encoding).Equals(Encoding.ASCII);
Check.That(response.Message.BodyData.BodyAsString).IsNull();
Check.That(response.Message.BodyData.BodyAsBytes).IsNull();
Check.That(((dynamic)response.Message.BodyData.BodyAsJson).value).Equals(42);
Check.That(response.Message.BodyData.Encoding).Equals(Encoding.ASCII);
}
[Fact]
@@ -198,23 +198,23 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost/test"), "GET", ClientIp);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithStatusCode(500)
.WithHeader("H1", "X1")
.WithHeader("H2", "X2")
.WithBody(req => $"path: {req.Path}");
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).IsEqualTo("path: /test");
Check.That(responseMessage.BodyData.BodyAsBytes).IsNull();
Check.That(responseMessage.BodyData.BodyAsJson).IsNull();
Check.That(responseMessage.BodyData.Encoding.CodePage).Equals(Encoding.UTF8.CodePage);
Check.That(responseMessage.StatusCode).IsEqualTo(500);
Check.That(responseMessage.Headers["H1"].ToString()).IsEqualTo("X1");
Check.That(responseMessage.Headers["H2"].ToString()).IsEqualTo("X2");
Check.That(response.Message.BodyData.BodyAsString).IsEqualTo("path: /test");
Check.That(response.Message.BodyData.BodyAsBytes).IsNull();
Check.That(response.Message.BodyData.BodyAsJson).IsNull();
Check.That(response.Message.BodyData.Encoding.CodePage).Equals(Encoding.UTF8.CodePage);
Check.That(response.Message.StatusCode).IsEqualTo(500);
Check.That(response.Message.Headers["H1"].ToString()).IsEqualTo("X1");
Check.That(response.Message.Headers["H2"].ToString()).IsEqualTo("X2");
}
[Fact]
@@ -223,7 +223,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost/test"), "GET", ClientIp);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithStatusCode(500)
.WithHeader("H1", "X1")
.WithHeader("H2", "X2")
@@ -234,16 +234,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
});
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).IsEqualTo("path: /test");
Check.That(responseMessage.BodyData.BodyAsBytes).IsNull();
Check.That(responseMessage.BodyData.BodyAsJson).IsNull();
Check.That(responseMessage.BodyData.Encoding.CodePage).Equals(Encoding.UTF8.CodePage);
Check.That(responseMessage.StatusCode).IsEqualTo(500);
Check.That(responseMessage.Headers["H1"].ToString()).IsEqualTo("X1");
Check.That(responseMessage.Headers["H2"].ToString()).IsEqualTo("X2");
Check.That(response.Message.BodyData.BodyAsString).IsEqualTo("path: /test");
Check.That(response.Message.BodyData.BodyAsBytes).IsNull();
Check.That(response.Message.BodyData.BodyAsJson).IsNull();
Check.That(response.Message.BodyData.Encoding.CodePage).Equals(Encoding.UTF8.CodePage);
Check.That(response.Message.StatusCode).IsEqualTo(500);
Check.That(response.Message.Headers["H1"].ToString()).IsEqualTo("X1");
Check.That(response.Message.Headers["H2"].ToString()).IsEqualTo("X2");
}
[Fact]
@@ -256,25 +256,25 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request1 = new RequestMessage(new UrlDetails($"http://localhost/test?id={request1Id}"), "GET", ClientIp);
var request2 = new RequestMessage(new UrlDetails($"http://localhost/test?id={request2Id}"), "GET", ClientIp);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithStatusCode(200)
.WithBodyAsJson(JObject.Parse("{ \"id\": \"{{request.query.id}}\" }"))
.WithTransformer();
// Act
var response1Message = await response.ProvideResponseAsync(request1, _settings);
var response2Message = await response.ProvideResponseAsync(request2, _settings);
var response1 = await responseBuilder.ProvideResponseAsync(request1, _settings);
var response2 = await responseBuilder.ProvideResponseAsync(request2, _settings);
// Assert
Check.That(((JToken)response1Message.BodyData.BodyAsJson).SelectToken("id")?.Value<int>()).IsEqualTo(request1Id);
Check.That(response1Message.BodyData.BodyAsBytes).IsNull();
Check.That(response1Message.BodyData.BodyAsString).IsNull();
Check.That(response1Message.StatusCode).IsEqualTo(200);
Check.That(((JToken)response1.Message.BodyData.BodyAsJson).SelectToken("id")?.Value<int>()).IsEqualTo(request1Id);
Check.That(response1.Message.BodyData.BodyAsBytes).IsNull();
Check.That(response1.Message.BodyData.BodyAsString).IsNull();
Check.That(response1.Message.StatusCode).IsEqualTo(200);
Check.That(((JToken)response2Message.BodyData.BodyAsJson).SelectToken("id")?.Value<int>()).IsEqualTo(request2Id);
Check.That(response2Message.BodyData.BodyAsBytes).IsNull();
Check.That(response2Message.BodyData.BodyAsString).IsNull();
Check.That(response2Message.StatusCode).IsEqualTo(200);
Check.That(((JToken)response2.Message.BodyData.BodyAsJson).SelectToken("id")?.Value<int>()).IsEqualTo(request2Id);
Check.That(response2.Message.BodyData.BodyAsBytes).IsNull();
Check.That(response2.Message.BodyData.BodyAsString).IsNull();
Check.That(response2.Message.StatusCode).IsEqualTo(200);
}
[Fact]
@@ -285,12 +285,12 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request1 = new RequestMessage(new UrlDetails("http://localhost/__admin/files/filename.txt"), "PUT", ClientIp, bodyDataAsFile);
var response = Response.Create().WithStatusCode(200).WithBody(fileContents);
var responseBuilder = Response.Create().WithStatusCode(200).WithBody(fileContents);
var provideResponseAsync = await response.ProvideResponseAsync(request1, _settings);
var response = await responseBuilder.ProvideResponseAsync(request1, _settings);
Check.That(provideResponseAsync.StatusCode).IsEqualTo(200);
Check.That(provideResponseAsync.BodyData.BodyAsString).Contains(fileContents);
Check.That(response.Message.StatusCode).IsEqualTo(200);
Check.That(response.Message.BodyData.BodyAsString).Contains(fileContents);
}
[Fact]
@@ -301,12 +301,12 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request1 = new RequestMessage(new UrlDetails("http://localhost/__admin/files/filename.txt"), "GET", ClientIp, bodyDataAsFile);
var response = Response.Create().WithStatusCode(200).WithBody(fileContents);
var responseBuilder = Response.Create().WithStatusCode(200).WithBody(fileContents);
var provideResponseAsync = await response.ProvideResponseAsync(request1, _settings);
var response = await responseBuilder.ProvideResponseAsync(request1, _settings);
Check.That(provideResponseAsync.StatusCode).IsEqualTo(200);
Check.That(provideResponseAsync.BodyData.BodyAsString).Contains(fileContents);
Check.That(response.Message.StatusCode).IsEqualTo(200);
Check.That(response.Message.BodyData.BodyAsString).Contains(fileContents);
}
[Fact]
@@ -317,12 +317,12 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request1 = new RequestMessage(new UrlDetails("http://localhost/__admin/files/filename.txt"), "DELETE", ClientIp, bodyDataAsFile);
var response = Response.Create().WithStatusCode(200).WithBody("File deleted.");
var responseBuilder = Response.Create().WithStatusCode(200).WithBody("File deleted.");
var provideResponseAsync = await response.ProvideResponseAsync(request1, _settings);
var response = await responseBuilder.ProvideResponseAsync(request1, _settings);
Check.That(provideResponseAsync.StatusCode).IsEqualTo(200);
Check.That(provideResponseAsync.BodyData.BodyAsString).Contains("File deleted.");
Check.That(response.Message.StatusCode).IsEqualTo(200);
Check.That(response.Message.BodyData.BodyAsString).Contains("File deleted.");
}
}
}

34
test/WireMock.Net.Tests/ResponseBuilders/ResponseWithCallbackTests.cs
View File

@@ -33,7 +33,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
{
// Assign
var requestMessage = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1");
var response = Response.Create()
var responseBuilder = Response.Create()
.WithCallback(async request =>
{
await Task.Delay(1);
@@ -50,11 +50,11 @@ namespace WireMock.Net.Tests.ResponseBuilders
});
// Act
var responseMessage = await response.ProvideResponseAsync(requestMessage, _settings);
var response = await responseBuilder.ProvideResponseAsync(requestMessage, _settings);
// Assert
responseMessage.BodyData.BodyAsString.Should().Be("/fooBar");
responseMessage.StatusCode.Should().Be(302);
response.Message.BodyData.BodyAsString.Should().Be("/fooBar");
response.Message.StatusCode.Should().Be(302);
}
[Fact]
@@ -62,7 +62,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
{
// Assign
var requestMessage = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1");
var response = Response.Create()
var responseBuilder = Response.Create()
.WithCallback(request => new ResponseMessage
{
BodyData = new BodyData
@@ -74,11 +74,11 @@ namespace WireMock.Net.Tests.ResponseBuilders
});
// Act
var responseMessage = await response.ProvideResponseAsync(requestMessage, _settings);
var response = await responseBuilder.ProvideResponseAsync(requestMessage, _settings);
// Assert
responseMessage.BodyData.BodyAsString.Should().Be("/fooBar");
responseMessage.StatusCode.Should().Be(302);
response.Message.BodyData.BodyAsString.Should().Be("/fooBar");
response.Message.StatusCode.Should().Be(302);
}
[Fact]
@@ -87,7 +87,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign
var header = "X-UserId";
var requestMessage = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1");
var response = Response.Create()
var responseBuilder = Response.Create()
.WithCallback(request => new ResponseMessage
{
BodyData = new BodyData
@@ -105,12 +105,12 @@ namespace WireMock.Net.Tests.ResponseBuilders
.WithHeader(header, "Stef");
// Act
var responseMessage = await response.ProvideResponseAsync(requestMessage, _settings);
var response = await responseBuilder.ProvideResponseAsync(requestMessage, _settings);
// Assert
responseMessage.BodyData.BodyAsString.Should().Be("/fooBar");
responseMessage.StatusCode.Should().Be(HttpStatusCode.Accepted);
responseMessage.Headers[header].Should().ContainSingle("Stef");
response.Message.BodyData.BodyAsString.Should().Be("/fooBar");
response.Message.StatusCode.Should().Be(HttpStatusCode.Accepted);
response.Message.Headers[header].Should().ContainSingle("Stef");
}
[Fact]
@@ -118,7 +118,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
{
// Assign
var requestMessage = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1");
var response = Response.Create()
var responseBuilder = Response.Create()
.WithCallback(request => new ResponseMessage
{
BodyData = new BodyData
@@ -131,11 +131,11 @@ namespace WireMock.Net.Tests.ResponseBuilders
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(requestMessage, _settings);
var response = await responseBuilder.ProvideResponseAsync(requestMessage, _settings);
// Assert
responseMessage.BodyData.BodyAsString.Should().Be("/fooBar");
responseMessage.StatusCode.Should().Be(302);
response.Message.BodyData.BodyAsString.Should().Be("/fooBar");
response.Message.StatusCode.Should().Be(302);
}
}
}

16
test/WireMock.Net.Tests/ResponseBuilders/ResponseWithFaultTests.cs
View File

@@ -21,12 +21,12 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost/fault"), "GET", ClientIp);
// Act
var response = Response.Create().WithFault(faultType);
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var responseBuilder = Response.Create().WithFault(faultType);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
responseMessage.FaultType.Should().Be(faultType);
responseMessage.FaultPercentage.Should().BeNull();
response.Message.FaultType.Should().Be(faultType);
response.Message.FaultPercentage.Should().BeNull();
}
[Theory]
@@ -37,12 +37,12 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost/fault"), "GET", ClientIp);
// Act
var response = Response.Create().WithFault(faultType, percentage);
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var responseBuilder = Response.Create().WithFault(faultType, percentage);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
responseMessage.FaultType.Should().Be(faultType);
responseMessage.FaultPercentage.Should().Be(percentage);
response.Message.FaultType.Should().Be(faultType);
response.Message.FaultPercentage.Should().Be(percentage);
}
}
}

195
test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHandlebarsFileTests.cs
View File

@@ -1,100 +1,99 @@
using System;
using System.Threading.Tasks;
using System.Threading.Tasks;
using HandlebarsDotNet;
using Moq;
using Newtonsoft.Json.Linq;
using NFluent;
using WireMock.Handlers;
using WireMock.Models;
using WireMock.ResponseBuilders;
using WireMock.Settings;
using Xunit;
namespace WireMock.Net.Tests.ResponseBuilders
{
public class ResponseWithHandlebarsFileTests
{
private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
private readonly WireMockServerSettings _settings = new WireMockServerSettings();
private const string ClientIp = "::1";
public ResponseWithHandlebarsFileTests()
{
_filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
_filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
_settings.FileSystemHandler = _filesystemHandlerMock.Object;
}
[Fact]
public async Task Response_ProvideResponseAsync_Handlebars_File()
{
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
var response = Response.Create()
.WithBodyAsJson(new
{
Data = "{{File \"x.json\"}}"
})
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
Check.That(j["Data"].Value<string>()).Equals("abc");
// Verify
_filesystemHandlerMock.Verify(fs => fs.ReadResponseBodyAsString("x.json"), Times.Once);
_filesystemHandlerMock.VerifyNoOtherCalls();
}
[Fact]
public async Task Response_ProvideResponseAsync_Handlebars_File_Replace()
{
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234?id=x"), "GET", ClientIp);
var response = Response.Create()
.WithBodyAsJson(new
{
Data = "{{File \"{{request.query.id}}.json\"}}"
})
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
Check.That(j["Data"].Value<string>()).Equals("abc");
// Verify
_filesystemHandlerMock.Verify(fs => fs.ReadResponseBodyAsString("x.json"), Times.Once);
_filesystemHandlerMock.VerifyNoOtherCalls();
}
[Fact]
public void Response_ProvideResponseAsync_Handlebars_File_WithMissingArgument_Throws_HandlebarsException()
{
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
var response = Response.Create()
.WithBodyAsJson(new
{
Data = "{{File}}"
})
.WithTransformer();
// Act
Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _settings)).Throws<HandlebarsException>();
// Verify
_filesystemHandlerMock.Verify(fs => fs.ReadResponseBodyAsString(It.IsAny<string>()), Times.Never);
_filesystemHandlerMock.VerifyNoOtherCalls();
}
}
using Moq;
using Newtonsoft.Json.Linq;
using NFluent;
using WireMock.Handlers;
using WireMock.Models;
using WireMock.ResponseBuilders;
using WireMock.Settings;
using Xunit;
namespace WireMock.Net.Tests.ResponseBuilders
{
public class ResponseWithHandlebarsFileTests
{
private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
private readonly WireMockServerSettings _settings = new WireMockServerSettings();
private const string ClientIp = "::1";
public ResponseWithHandlebarsFileTests()
{
_filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
_filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
_settings.FileSystemHandler = _filesystemHandlerMock.Object;
}
[Fact]
public async Task Response_ProvideResponseAsync_Handlebars_File()
{
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
var responseBuilder = Response.Create()
.WithBodyAsJson(new
{
Data = "{{File \"x.json\"}}"
})
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["Data"].Value<string>()).Equals("abc");
// Verify
_filesystemHandlerMock.Verify(fs => fs.ReadResponseBodyAsString("x.json"), Times.Once);
_filesystemHandlerMock.VerifyNoOtherCalls();
}
[Fact]
public async Task Response_ProvideResponseAsync_Handlebars_File_Replace()
{
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234?id=x"), "GET", ClientIp);
var responseBuilder = Response.Create()
.WithBodyAsJson(new
{
Data = "{{File \"{{request.query.id}}.json\"}}"
})
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["Data"].Value<string>()).Equals("abc");
// Verify
_filesystemHandlerMock.Verify(fs => fs.ReadResponseBodyAsString("x.json"), Times.Once);
_filesystemHandlerMock.VerifyNoOtherCalls();
}
[Fact]
public void Response_ProvideResponseAsync_Handlebars_File_WithMissingArgument_Throws_HandlebarsException()
{
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
var responseBuilder = Response.Create()
.WithBodyAsJson(new
{
Data = "{{File}}"
})
.WithTransformer();
// Act
Check.ThatAsyncCode(() => responseBuilder.ProvideResponseAsync(request, _settings)).Throws<HandlebarsException>();
// Verify
_filesystemHandlerMock.Verify(fs => fs.ReadResponseBodyAsString(It.IsAny<string>()), Times.Never);
_filesystemHandlerMock.VerifyNoOtherCalls();
}
}
}

6
test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHandlebarsHelpersTests.cs
View File

@@ -34,15 +34,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBody("{{String.Uppercase request.body}}")
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("ABC");
Check.That(response.Message.BodyData.BodyAsString).Equals("ABC");
}
}
}

46
test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHandlebarsJsonPathTests.cs
View File

@@ -71,16 +71,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/json")
.WithBodyAsJson(new { x = "{{JsonPath.SelectToken request.body \"$.Manufacturers[?(@.Name == 'Acme Co')]\"}}" })
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["x"]).IsNotNull();
Check.That(j["x"]["Name"].ToString()).Equals("Acme Co");
}
@@ -97,16 +97,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/json")
.WithBodyAsJson(new { x = "{{JsonPath.SelectToken request.body \"..Price\"}}" })
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["x"].Value<long>()).Equals(99);
}
@@ -151,16 +151,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/json")
.WithBody("{{JsonPath.SelectToken request.body \"$.Manufacturers[?(@.Name == 'Acme Co')]\"}}")
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals($"{{{Environment.NewLine} \"Name\": \"Acme Co\",{Environment.NewLine} \"Products\": [{Environment.NewLine} {{{Environment.NewLine} \"Name\": \"Anvil\",{Environment.NewLine} \"Price\": 50{Environment.NewLine} }}{Environment.NewLine} ]{Environment.NewLine}}}");
Check.That(response.Message.BodyData.BodyAsString).Equals($"{{{Environment.NewLine} \"Name\": \"Acme Co\",{Environment.NewLine} \"Products\": [{Environment.NewLine} {{{Environment.NewLine} \"Name\": \"Anvil\",{Environment.NewLine} \"Price\": 50{Environment.NewLine} }}{Environment.NewLine} ]{Environment.NewLine}}}");
}
[Fact]
@@ -204,16 +204,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/json")
.WithBody("{{JsonPath.SelectToken request.bodyAsJson \"$.Manufacturers[?(@.Name == 'Acme Co')]\"}}")
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals($"{{{Environment.NewLine} \"Name\": \"Acme Co\",{Environment.NewLine} \"Products\": [{Environment.NewLine} {{{Environment.NewLine} \"Name\": \"Anvil\",{Environment.NewLine} \"Price\": 50{Environment.NewLine} }}{Environment.NewLine} ]{Environment.NewLine}}}");
Check.That(response.Message.BodyData.BodyAsString).Equals($"{{{Environment.NewLine} \"Name\": \"Acme Co\",{Environment.NewLine} \"Products\": [{Environment.NewLine} {{{Environment.NewLine} \"Name\": \"Anvil\",{Environment.NewLine} \"Price\": 50{Environment.NewLine} }}{Environment.NewLine} ]{Environment.NewLine}}}");
}
[Fact]
@@ -257,16 +257,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/json")
.WithBody("{{#JsonPath.SelectTokens request.body \"$..Products[?(@.Price >= 50)].Name\"}}{{#each this}}%{{@index}}:{{this}}%{{/each}}{{/JsonPath.SelectTokens}}")
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("%0:Anvil%%1:Elbow Grease%");
Check.That(response.Message.BodyData.BodyAsString).Equals("%0:Anvil%%1:Elbow Grease%");
}
[Fact]
@@ -310,16 +310,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/json")
.WithBody("{{#JsonPath.SelectTokens request.bodyAsJson \"$..Products[?(@.Price >= 50)].Name\"}}{{#each this}}%{{@index}}:{{this}}%{{/each}}{{/JsonPath.SelectTokens}}")
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("%0:Anvil%%1:Elbow Grease%");
Check.That(response.Message.BodyData.BodyAsString).Equals("%0:Anvil%%1:Elbow Grease%");
}
[Fact]
@@ -339,13 +339,13 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/json")
.WithBody("{{#JsonPath.SelectTokens request.body \"$..Products[?(@.Price >= 50)].Name\"}}{{id}} {{value}},{{/JsonPath.SelectTokens}}")
.WithTransformer();
// Act
Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _settings)).Throws<ArgumentNullException>();
Check.ThatAsyncCode(() => responseBuilder.ProvideResponseAsync(request, _settings)).Throws<ArgumentNullException>();
}
[Fact]
@@ -364,15 +364,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, bodyData);
string jsonPath = "\"$.MyUniqueNumber\"";
var response = Response.Create()
var responseBuilder = Response.Create()
.WithTransformer()
.WithBodyFromFile(@"c:\\{{JsonPath.SelectToken request.body " + jsonPath + "}}\\test.json"); // why use a \\ here ?
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsFile).Equals(@"c:\1\test.json");
Check.That(response.Message.BodyData.BodyAsFile).Equals(@"c:\1\test.json");
}
}
}

492
test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHandlebarsLinqTests.cs
View File

@@ -1,249 +1,249 @@
using System;
using System.Threading.Tasks;
using System;
using System.Threading.Tasks;
using FluentAssertions;
using HandlebarsDotNet;
using Moq;
using Newtonsoft.Json.Linq;
using NFluent;
using WireMock.Handlers;
using WireMock.Models;
using WireMock.ResponseBuilders;
using WireMock.Settings;
using WireMock.Types;
using WireMock.Util;
using Xunit;
namespace WireMock.Net.Tests.ResponseBuilders
{
public class ResponseWithHandlebarsLinqTests
{
private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
private readonly WireMockServerSettings _settings = new WireMockServerSettings();
public ResponseWithHandlebarsLinqTests()
{
_filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
_filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
_settings.FileSystemHandler = _filesystemHandlerMock.Object;
}
[Fact]
public async Task Response_ProvideResponse_Handlebars_Linq1_String0()
{
// Assign
var body = new BodyData();
var request = new RequestMessage(new UrlDetails("http://localhost:1234/pathtest"), "POST", "::1", body);
var response = Response.Create()
.WithHeader("Content-Type", "application/json")
.WithBodyAsJson(new { x = "{{Linq request.Path 'it'}}" })
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
Check.That(j["x"]).IsNotNull();
Check.That(j["x"].ToString()).Equals("/pathtest");
}
[Fact]
public async Task Response_ProvideResponse_Handlebars_Linq1_String1()
{
// Assign
var body = new BodyData
{
BodyAsJson = new JObject
{
{ "Id", new JValue(9) },
{ "Name", new JValue("Test") }
},
DetectedBodyType = BodyType.Json
};
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var response = Response.Create()
.WithHeader("Content-Type", "application/json")
.WithBodyAsJson(new { x = "{{Linq request.bodyAsJson 'it.Name + \"_123\"' }}" })
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
Check.That(j["x"]).IsNotNull();
Check.That(j["x"].ToString()).Equals("Test_123");
}
[Fact]
public async Task Response_ProvideResponse_Handlebars_Linq1_String2()
{
// Assign
var body = new BodyData
{
BodyAsJson = new JObject
{
{ "Id", new JValue(9) },
{ "Name", new JValue("Test") }
},
DetectedBodyType = BodyType.Json
};
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var response = Response.Create()
.WithHeader("Content-Type", "application/json")
.WithBodyAsJson(new { x = "{{Linq request.bodyAsJson 'new(it.Name + \"_123\" as N, it.Id as I)' }}" })
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
Check.That(j["x"]).IsNotNull();
Check.That(j["x"].ToString()).Equals("{ N = Test_123, I = 9 }");
}
[Fact]
public async Task Response_ProvideResponse_Handlebars_Linq2_Object()
{
// Assign
var body = new BodyData
{
BodyAsJson = new JObject
{
{ "Id", new JValue(9) },
{ "Name", new JValue("Test") }
},
DetectedBodyType = BodyType.Json
};
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var response = Response.Create()
.WithHeader("Content-Type", "application/json")
.WithBodyAsJson(new { x = "{{#Linq request.bodyAsJson 'new(it.Name + \"_123\" as N, it.Id as I)' }}{{this}}{{/Linq}}" })
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
Check.That(j["x"]).IsNotNull();
Check.That(j["x"].ToString()).Equals("{ N = Test_123, I = 9 }");
}
[Fact]
public void Response_ProvideResponse_Handlebars_Linq_Throws_ArgumentException()
{
// Assign
var body = new BodyData
{
BodyAsJson = new { x = "x" },
DetectedBodyType = BodyType.Json
};
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var response = Response.Create()
.WithBodyAsJson(new { x = "{{Linq request.bodyAsJson 1}}" })
.WithTransformer();
// Act
Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _settings)).Throws<ArgumentException>();
}
[Fact]
public void Response_ProvideResponse_Handlebars_Linq1_Throws_ArgumentNullException()
{
// Assign
var body = new BodyData();
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var response = Response.Create()
.WithBodyAsJson(new { x = "{{Linq request.body 'Name'}}" })
.WithTransformer();
// Act
Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _settings)).Throws<ArgumentNullException>();
}
[Fact]
public void Response_ProvideResponse_Handlebars_Linq1_Throws_HandlebarsException()
{
// Assign
var body = new BodyData();
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var response = Response.Create()
.WithBodyAsJson(new { x = "{{Linq request.bodyAsJson}} ''" })
.WithTransformer();
// Act
Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _settings)).Throws<HandlebarsException>();
}
[Fact]
public void Response_ProvideResponse_Handlebars_Linq1_ParseError_Throws_ExceptionMessage()
{
// Assign
var body = new BodyData
{
BodyAsJson = new JObject
{
{ "Id", new JValue(9) },
{ "Name", new JValue("Test") }
},
DetectedBodyType = BodyType.Json
};
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var response = Response.Create()
.WithBodyAsJson(new { x = "{{Linq request.bodyAsJson '---' }}" })
.WithTransformer();
// Act
Func<Task> a = async () => await response.ProvideResponseAsync(request, _settings);
// Assert
a.Should().Throw<HandlebarsException>();
}
[Fact]
public void Response_ProvideResponse_Handlebars_Linq2_ParseError_Throws_ExceptionMessage()
{
// Assign
var body = new BodyData
{
BodyAsJson = new JObject
{
{ "Id", new JValue(9) },
{ "Name", new JValue("Test") }
},
DetectedBodyType = BodyType.Json
};
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var response = Response.Create()
.WithBodyAsJson(new { x = "{{#Linq request.bodyAsJson '---' }}{{this}}{{/Linq}}" })
.WithTransformer();
// Act
Func<Task> a = async () => await response.ProvideResponseAsync(request, _settings);
// Assert
a.Should().Throw<HandlebarsException>();
}
}
using Moq;
using Newtonsoft.Json.Linq;
using NFluent;
using WireMock.Handlers;
using WireMock.Models;
using WireMock.ResponseBuilders;
using WireMock.Settings;
using WireMock.Types;
using WireMock.Util;
using Xunit;
namespace WireMock.Net.Tests.ResponseBuilders
{
public class ResponseWithHandlebarsLinqTests
{
private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
private readonly WireMockServerSettings _settings = new WireMockServerSettings();
public ResponseWithHandlebarsLinqTests()
{
_filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
_filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
_settings.FileSystemHandler = _filesystemHandlerMock.Object;
}
[Fact]
public async Task Response_ProvideResponse_Handlebars_Linq1_String0()
{
// Assign
var body = new BodyData();
var request = new RequestMessage(new UrlDetails("http://localhost:1234/pathtest"), "POST", "::1", body);
var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/json")
.WithBodyAsJson(new { x = "{{Linq request.Path 'it'}}" })
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["x"]).IsNotNull();
Check.That(j["x"].ToString()).Equals("/pathtest");
}
[Fact]
public async Task Response_ProvideResponse_Handlebars_Linq1_String1()
{
// Assign
var body = new BodyData
{
BodyAsJson = new JObject
{
{ "Id", new JValue(9) },
{ "Name", new JValue("Test") }
},
DetectedBodyType = BodyType.Json
};
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/json")
.WithBodyAsJson(new { x = "{{Linq request.bodyAsJson 'it.Name + \"_123\"' }}" })
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["x"]).IsNotNull();
Check.That(j["x"].ToString()).Equals("Test_123");
}
[Fact]
public async Task Response_ProvideResponse_Handlebars_Linq1_String2()
{
// Assign
var body = new BodyData
{
BodyAsJson = new JObject
{
{ "Id", new JValue(9) },
{ "Name", new JValue("Test") }
},
DetectedBodyType = BodyType.Json
};
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/json")
.WithBodyAsJson(new { x = "{{Linq request.bodyAsJson 'new(it.Name + \"_123\" as N, it.Id as I)' }}" })
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["x"]).IsNotNull();
Check.That(j["x"].ToString()).Equals("{ N = Test_123, I = 9 }");
}
[Fact]
public async Task Response_ProvideResponse_Handlebars_Linq2_Object()
{
// Assign
var body = new BodyData
{
BodyAsJson = new JObject
{
{ "Id", new JValue(9) },
{ "Name", new JValue("Test") }
},
DetectedBodyType = BodyType.Json
};
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/json")
.WithBodyAsJson(new { x = "{{#Linq request.bodyAsJson 'new(it.Name + \"_123\" as N, it.Id as I)' }}{{this}}{{/Linq}}" })
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["x"]).IsNotNull();
Check.That(j["x"].ToString()).Equals("{ N = Test_123, I = 9 }");
}
[Fact]
public void Response_ProvideResponse_Handlebars_Linq_Throws_ArgumentException()
{
// Assign
var body = new BodyData
{
BodyAsJson = new { x = "x" },
DetectedBodyType = BodyType.Json
};
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var responseBuilder = Response.Create()
.WithBodyAsJson(new { x = "{{Linq request.bodyAsJson 1}}" })
.WithTransformer();
// Act
Check.ThatAsyncCode(() => responseBuilder.ProvideResponseAsync(request, _settings)).Throws<ArgumentException>();
}
[Fact]
public void Response_ProvideResponse_Handlebars_Linq1_Throws_ArgumentNullException()
{
// Assign
var body = new BodyData();
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var responseBuilder = Response.Create()
.WithBodyAsJson(new { x = "{{Linq request.body 'Name'}}" })
.WithTransformer();
// Act
Check.ThatAsyncCode(() => responseBuilder.ProvideResponseAsync(request, _settings)).Throws<ArgumentNullException>();
}
[Fact]
public void Response_ProvideResponse_Handlebars_Linq1_Throws_HandlebarsException()
{
// Assign
var body = new BodyData();
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var responseBuilder = Response.Create()
.WithBodyAsJson(new { x = "{{Linq request.bodyAsJson}} ''" })
.WithTransformer();
// Act
Check.ThatAsyncCode(() => responseBuilder.ProvideResponseAsync(request, _settings)).Throws<HandlebarsException>();
}
[Fact]
public void Response_ProvideResponse_Handlebars_Linq1_ParseError_Throws_ExceptionMessage()
{
// Assign
var body = new BodyData
{
BodyAsJson = new JObject
{
{ "Id", new JValue(9) },
{ "Name", new JValue("Test") }
},
DetectedBodyType = BodyType.Json
};
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var responseBuilder = Response.Create()
.WithBodyAsJson(new { x = "{{Linq request.bodyAsJson '---' }}" })
.WithTransformer();
// Act
Func<Task> a = async () => await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
a.Should().Throw<HandlebarsException>();
}
[Fact]
public void Response_ProvideResponse_Handlebars_Linq2_ParseError_Throws_ExceptionMessage()
{
// Assign
var body = new BodyData
{
BodyAsJson = new JObject
{
{ "Id", new JValue(9) },
{ "Name", new JValue("Test") }
},
DetectedBodyType = BodyType.Json
};
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var responseBuilder = Response.Create()
.WithBodyAsJson(new { x = "{{#Linq request.bodyAsJson '---' }}{{this}}{{/Linq}}" })
.WithTransformer();
// Act
Func<Task> a = async () => await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
a.Should().Throw<HandlebarsException>();
}
}
}

30
test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHandlebarsRandomTests.cs
View File

@@ -32,7 +32,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBodyAsJson(new
{
Text = "{{Random Type=\"Text\" Min=8 Max=20}}",
@@ -43,10 +43,10 @@ namespace WireMock.Net.Tests.ResponseBuilders
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["Text"].Value<string>()).IsNotEmpty();
Check.That(j["Integer"].Value<int>()).IsEqualTo(1000);
Check.That(j["Long"].Value<long>()).IsStrictlyGreaterThan(77777777).And.IsStrictlyLessThan(99999999);
@@ -58,7 +58,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBodyAsJson(new
{
Value = "{{Random Type=\"Boolean\"}}"
@@ -66,10 +66,10 @@ namespace WireMock.Net.Tests.ResponseBuilders
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["Value"].Type).IsEqualTo(JTokenType.Boolean);
}
@@ -79,7 +79,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBodyAsJson(new
{
Guid1 = "{{Random Type=\"Guid\" Uppercase=false}}",
@@ -88,10 +88,10 @@ namespace WireMock.Net.Tests.ResponseBuilders
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
string guid1 = j["Guid1"].Value<string>();
Check.That(guid1.ToUpper()).IsNotEqualTo(guid1);
string guid2 = j["Guid2"].Value<string>();
@@ -104,7 +104,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBodyAsJson(new
{
StringValue = "{{Random Type=\"StringList\" Values=[\"a\", \"b\", \"c\"]}}"
@@ -112,10 +112,10 @@ namespace WireMock.Net.Tests.ResponseBuilders
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
string value = j["StringValue"].Value<string>();
Check.That(new[] { "a", "b", "c" }.Contains(value)).IsTrue();
}
@@ -126,7 +126,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBodyAsJson(new
{
Integer = "{{#Random Type=\"Integer\" Min=10000000 Max=99999999}}{{this}}{{/Random}}",
@@ -134,10 +134,10 @@ namespace WireMock.Net.Tests.ResponseBuilders
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["Integer"].Value<int>()).IsStrictlyGreaterThan(10000000).And.IsStrictlyLessThan(99999999);
}
}

40
test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHandlebarsRegexTests.cs
View File

@@ -35,15 +35,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBody("{{Regex.Match request.body \"^(\\w+)$\"}}")
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("abc");
Check.That(response.Message.BodyData.BodyAsString).Equals("abc");
}
[Fact]
@@ -54,15 +54,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBody("{{Regex.Match request.body \"^?0$\"}}")
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("");
Check.That(response.Message.BodyData.BodyAsString).Equals("");
}
[Fact]
@@ -73,15 +73,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBody("{{Regex.Match request.body \"^?0$\" \"d\"}}")
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("d");
Check.That(response.Message.BodyData.BodyAsString).Equals("d");
}
[Fact]
@@ -92,15 +92,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBody("{{#Regex.Match request.body \"^(?<proto>\\w+)://[^/]+?(?<port>\\d+)/?\"}}{{this.port}}-{{this.proto}}{{/Regex.Match}}")
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("5000-https");
Check.That(response.Message.BodyData.BodyAsString).Equals("5000-https");
}
[Fact]
@@ -111,15 +111,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBody("{{#Regex.Match request.body \"^(?<proto>\\w+)://[^/]+?(?<port>\\d+)/?\"}}{{this}}{{/Regex.Match}}")
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("");
Check.That(response.Message.BodyData.BodyAsString).Equals("");
}
[Fact]
@@ -130,15 +130,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBody("{{#Regex.Match request.body \"^(?<proto>\\w+)://[^/]+?(?<port>\\d+)/?\" \"x\"}}{{this}}{{/Regex.Match}}")
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("x");
Check.That(response.Message.BodyData.BodyAsString).Equals("x");
}
[Fact]
@@ -149,12 +149,12 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBody("{{#Regex.Match request.bodyAsJson \"^(?<proto>\\w+)://[^/]+?(?<port>\\d+)/?\"}}{{/Regex.Match}}")
.WithTransformer();
// Act and Assert
Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _settings)).Throws<ArgumentNullException>();
Check.ThatAsyncCode(() => responseBuilder.ProvideResponseAsync(request, _settings)).Throws<ArgumentNullException>();
}
}
}

30
test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHandlebarsXPathTests.cs
View File

@@ -46,16 +46,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/xml")
.WithBody("<response>{{XPath.SelectSingleNode request.body \"/todo-list/todo-item[1]\"}}</response>")
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
var nav = new XmlDocument { InnerXml = responseMessage.BodyData.BodyAsString }.CreateNavigator();
var nav = new XmlDocument { InnerXml = response.Message.BodyData.BodyAsString }.CreateNavigator();
var node = nav.XPath2SelectSingleNode("/response/todo-item");
Check.That(node.Value).Equals("abc");
Check.That(node.GetAttribute("id", "")).Equals("a1");
@@ -77,16 +77,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/xml")
.WithBody("{{XPath.SelectSingleNode request.body \"/todo-list/todo-item[1]/text()\"}}")
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).IsEqualTo("abc");
Check.That(response.Message.BodyData.BodyAsString).IsEqualTo("abc");
}
[Fact]
@@ -105,16 +105,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/xml")
.WithBody("<response>{{XPath.SelectNodes request.body \"/todo-list/todo-item\"}}</response>")
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
var nav = new XmlDocument { InnerXml = responseMessage.BodyData.BodyAsString }.CreateNavigator();
var nav = new XmlDocument { InnerXml = response.Message.BodyData.BodyAsString }.CreateNavigator();
var nodes = nav.XPath2SelectNodes("/response/todo-item");
Check.That(nodes.Count + 1).IsEqualTo(3);
}
@@ -135,16 +135,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/xml")
.WithBody("{{XPath.Evaluate request.body \"boolean(/todo-list[count(todo-item) = 3])\"}}")
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).IsEqualIgnoringCase("True");
Check.That(response.Message.BodyData.BodyAsString).IsEqualIgnoringCase("True");
}
[Fact]
@@ -163,16 +163,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/xml")
.WithBody("{{XPath.Evaluate request.body \"string(/todo-list/todo-item[1]/@id)\"}}")
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).IsEqualTo("a1");
Check.That(response.Message.BodyData.BodyAsString).IsEqualTo("a1");
}
}
}

12
test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHandlebarsXegerTests.cs
View File

@@ -31,7 +31,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBodyAsJson(new
{
Number = "{{Xeger.Generate \"[1-9]{1}\\d{3}\"}}",
@@ -40,10 +40,10 @@ namespace WireMock.Net.Tests.ResponseBuilders
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["Number"].Value<int>()).IsStrictlyGreaterThan(1000).And.IsStrictlyLessThan(9999);
Check.That(j["Postcode"].Value<string>()).IsNotEmpty();
}
@@ -54,7 +54,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBodyAsJson(new
{
Number = "{{#Xeger.Generate \"[1-9]{1}\\d{3}\"}}{{this}}{{/Xeger.Generate}}",
@@ -63,10 +63,10 @@ namespace WireMock.Net.Tests.ResponseBuilders
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["Number"].Value<int>()).IsStrictlyGreaterThan(1000).And.IsStrictlyLessThan(9999);
Check.That(j["Postcode"].Value<string>()).IsNotEmpty();
}

18
test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHeadersTests.cs
View File

@@ -28,7 +28,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
var response = await builder.ProvideResponseAsync(requestMock, _settings);
// Assert
Check.That(response.Headers[headerName].ToString()).Equals(headerValue);
Check.That(response.Message.Headers[headerName].ToString()).Equals(headerValue);
}
[Theory]
@@ -44,7 +44,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
var response = await builder.ProvideResponseAsync(requestMock, _settings);
// Assert
Check.That(response.Headers[headerName].ToArray()).Equals(headerValues);
Check.That(response.Message.Headers[headerName].ToArray()).Equals(headerValues);
}
[Fact]
@@ -59,7 +59,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
var responseMessage = await response.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.Headers["h"]).ContainsExactly("x");
Check.That(responseMessage.Message.Headers["h"]).ContainsExactly("x");
}
[Fact]
@@ -68,13 +68,13 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost"), "GET", ClientIp);
var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
var response = Response.Create().WithHeaders(headers);
var responseBuilder = Response.Create().WithHeaders(headers);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.Headers["h"]).ContainsExactly("x");
Check.That(response.Message.Headers["h"]).ContainsExactly("x");
}
[Fact]
@@ -83,13 +83,13 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost"), "GET", ClientIp);
var headers = new Dictionary<string, WireMockList<string>> { { "h", new WireMockList<string>("x") } };
var response = Response.Create().WithHeaders(headers);
var builder = Response.Create().WithHeaders(headers);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await builder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.Headers["h"]).ContainsExactly("x");
Check.That(response.Message.Headers["h"]).ContainsExactly("x");
}
}
}

14
test/WireMock.Net.Tests/ResponseBuilders/ResponseWithProxyTests.cs
View File

@@ -46,16 +46,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign
var headers = new Dictionary<string, string[]> { { "Content-Type", new[] { "application/xml" } } };
var request = new RequestMessage(new UrlDetails($"{_server.Urls[0]}{prepend}/{_guid}{append}"), "POST", ClientIp, new BodyData { DetectedBodyType = BodyType.Json, BodyAsJson = new { a = 1 } }, headers);
var response = Response.Create().WithProxy(_server.Urls[0]);
var responseBuilder = Response.Create().WithProxy(_server.Urls[0]);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(request.ProxyUrl).IsNotNull();
Check.That(responseMessage.BodyData.BodyAsString).IsEqualTo(expectedBody);
Check.That(responseMessage.StatusCode).IsEqualTo(201);
Check.That(responseMessage.Headers["Content-Type"].ToString()).IsEqualTo("application/json");
Check.That(response.Message.BodyData.BodyAsString).IsEqualTo(expectedBody);
Check.That(response.Message.StatusCode).IsEqualTo(201);
Check.That(response.Message.Headers["Content-Type"].ToString()).IsEqualTo("application/json");
}
[Fact]
@@ -72,12 +72,12 @@ namespace WireMock.Net.Tests.ResponseBuilders
Password = "y"
}
};
var response = Response.Create().WithProxy(settings);
var responseBuilder = Response.Create().WithProxy(settings);
// Act
var request = new RequestMessage(new UrlDetails($"{_server.Urls[0]}/{_guid}"), "GET", ClientIp);
Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _settings)).Throws<HttpRequestException>();
Check.ThatAsyncCode(() => responseBuilder.ProvideResponseAsync(request, _settings)).Throws<HttpRequestException>();
}
public void Dispose()

12
test/WireMock.Net.Tests/ResponseBuilders/ResponseWithScribanTests.cs
View File

@@ -40,13 +40,13 @@ namespace WireMock.Net.Tests.ResponseBuilders
var urlDetails = UrlUtils.Parse(new Uri("http://localhost/wiremock/a/b"), new PathString("/wiremock"));
var request = new RequestMessage(urlDetails, "GET", ClientIp);
var response = Response.Create().WithTransformer(TransformerType.ScribanDotLiquid);
var responseBuilder = Response.Create().WithTransformer(TransformerType.ScribanDotLiquid);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
responseMessage.BodyData.Should().BeNull();
response.Message.BodyData.Should().BeNull();
}
[Fact]
@@ -60,15 +60,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POSt", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBody("test {{request.Url}} {{request.Path}} {{request.Method}}")
.WithTransformer(TransformerType.Scriban);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("test http://localhost/foo /foo POSt");
Check.That(response.Message.BodyData.BodyAsString).Equals("test http://localhost/foo /foo POSt");
}
}
}

12
test/WireMock.Net.Tests/ResponseBuilders/ResponseWithStatusCodeTests.cs
View File

@@ -24,26 +24,26 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost/fault"), "GET", ClientIp);
// Act
var response = Response.Create();
var responseBuilder = Response.Create();
switch (statusCode)
{
case string statusCodeAsString:
response = response.WithStatusCode(statusCodeAsString);
responseBuilder = responseBuilder.WithStatusCode(statusCodeAsString);
break;
case int statusCodeAInteger:
response = response.WithStatusCode(statusCodeAInteger);
responseBuilder = responseBuilder.WithStatusCode(statusCodeAInteger);
break;
case HttpStatusCode statusCodeAsEnum:
response = response.WithStatusCode(statusCodeAsEnum);
responseBuilder = responseBuilder.WithStatusCode(statusCodeAsEnum);
break;
}
var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
var response = await responseBuilder.ProvideResponseAsync(request, _settingsMock.Object);
// Assert
responseMessage.StatusCode.Should().Be(expectedStatusCode);
response.Message.StatusCode.Should().Be(expectedStatusCode);
}
}
}

166
test/WireMock.Net.Tests/ResponseBuilders/ResponseWithTransformerTests.cs
View File

@@ -46,13 +46,13 @@ namespace WireMock.Net.Tests.ResponseBuilders
var urlDetails = UrlUtils.Parse(new Uri("http://localhost/wiremock/a/b"), new PathString("/wiremock"));
var request = new RequestMessage(urlDetails, "GET", ClientIp);
var response = Response.Create().WithTransformer(transformerType);
var responseBuilder = Response.Create().WithTransformer(transformerType);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
responseMessage.BodyData.Should().BeNull();
response.Message.BodyData.Should().BeNull();
}
[Theory]
@@ -69,15 +69,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POSt", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBody("test {{request.Url}} {{request.Path}} {{request.Method}}")
.WithTransformer(transformerType);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("test http://localhost/foo /foo POSt");
Check.That(response.Message.BodyData.BodyAsString).Equals("test http://localhost/foo /foo POSt");
}
[Theory]
@@ -93,15 +93,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
var urlDetails = UrlUtils.Parse(new Uri("http://localhost/wiremock/a/b"), new PathString("/wiremock"));
var request = new RequestMessage(urlDetails, httpMethod, ClientIp);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBody("url={{request.Url}} absoluteurl={{request.AbsoluteUrl}} path={{request.Path}} absolutepath={{request.AbsolutePath}}")
.WithTransformer(transformerType);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("url=http://localhost/a/b absoluteurl=http://localhost/wiremock/a/b path=/a/b absolutepath=/wiremock/a/b");
Check.That(response.Message.BodyData.BodyAsString).Equals("url=http://localhost/a/b absoluteurl=http://localhost/wiremock/a/b path=/a/b absolutepath=/wiremock/a/b");
}
[Fact]
@@ -111,15 +111,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
var urlDetails = UrlUtils.Parse(new Uri("http://localhost/wiremock/a/b"), new PathString("/wiremock"));
var request = new RequestMessage(urlDetails, "POST", ClientIp);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBody("{{request.PathSegments.[0]}} {{request.AbsolutePathSegments.[0]}}")
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("a wiremock");
Check.That(response.Message.BodyData.BodyAsString).Equals("a wiremock");
}
[Theory(Skip = "Invalid token `OpenBracket`")]
@@ -131,15 +131,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
var urlDetails = UrlUtils.Parse(new Uri("http://localhost/wiremock/a/b"), new PathString("/wiremock"));
var request = new RequestMessage(urlDetails, "POST", ClientIp);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBody("{{request.PathSegments.[0]}} {{request.AbsolutePathSegments.[0]}}")
.WithTransformer(transformerType);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("a wiremock");
Check.That(response.Message.BodyData.BodyAsString).Equals("a wiremock");
}
[Fact]
@@ -153,15 +153,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo?a=1&a=2&b=5"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBody("test keya={{request.query.a}} idx={{request.query.a.[0]}} idx={{request.query.a.[1]}} keyb={{request.query.b}}")
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("test keya=1,2 idx=1 idx=2 keyb=5");
Check.That(response.Message.BodyData.BodyAsString).Equals("test keya=1,2 idx=1 idx=2 keyb=5");
}
[Theory(Skip = "Invalid token `OpenBracket`")]
@@ -177,15 +177,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo?a=1&a=2&b=5"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBody("test keya={{request.query.a}} idx={{request.query.a.[0]}} idx={{request.query.a.[1]}} keyb={{request.query.b}}")
.WithTransformer(transformerType);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("test keya=1 idx=1 idx=2 keyb=5");
Check.That(response.Message.BodyData.BodyAsString).Equals("test keya=1 idx=1 idx=2 keyb=5");
}
[Fact]
@@ -199,17 +199,17 @@ namespace WireMock.Net.Tests.ResponseBuilders
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo?a=400"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithStatusCode("{{request.query.a}}")
.WithBody("test")
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("test");
Check.That(responseMessage.StatusCode).Equals("400");
Check.That(response.Message.BodyData.BodyAsString).Equals("test");
Check.That(response.Message.StatusCode).Equals("400");
}
[Theory(Skip = "WireMockList is not supported by Scriban")]
@@ -225,17 +225,17 @@ namespace WireMock.Net.Tests.ResponseBuilders
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo?a=400"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithStatusCode("{{request.Query.a}}")
.WithBody("test")
.WithTransformer(transformerType);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("test");
Check.That(responseMessage.StatusCode).Equals("400");
Check.That(response.Message.BodyData.BodyAsString).Equals("test");
Check.That(response.Message.StatusCode).Equals("400");
}
[Theory]
@@ -252,16 +252,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo?a=400"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBody("test")
.WithTransformer(transformerType);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("test");
Check.That(responseMessage.StatusCode).Equals(null);
Check.That(response.Message.BodyData.BodyAsString).Equals("test");
Check.That(response.Message.StatusCode).Equals(null);
}
[Fact]
@@ -275,15 +275,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, body, new Dictionary<string, string[]> { { "Content-Type", new[] { "text/plain" } } });
var response = Response.Create().WithHeader("x", "{{request.headers.Content-Type}}").WithBody("test").WithTransformer();
var responseBuilder = Response.Create().WithHeader("x", "{{request.headers.Content-Type}}").WithBody("test").WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("test");
Check.That(responseMessage.Headers).ContainsKey("x");
Check.That(responseMessage.Headers["x"]).ContainsExactly("text/plain");
Check.That(response.Message.BodyData.BodyAsString).Equals("test");
Check.That(response.Message.Headers).ContainsKey("x");
Check.That(response.Message.Headers["x"]).ContainsExactly("text/plain");
}
[Fact]
@@ -297,16 +297,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, body, new Dictionary<string, string[]> { { "Content-Type", new[] { "text/plain" } } });
var response = Response.Create().WithHeader("x", "{{request.headers.Content-Type}}", "{{request.url}}").WithBody("test").WithTransformer();
var responseBuilder = Response.Create().WithHeader("x", "{{request.headers.Content-Type}}", "{{request.url}}").WithBody("test").WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("test");
Check.That(responseMessage.Headers).ContainsKey("x");
Check.That(responseMessage.Headers["x"]).Contains("text/plain");
Check.That(responseMessage.Headers["x"]).Contains("http://localhost/foo");
Check.That(response.Message.BodyData.BodyAsString).Equals("test");
Check.That(response.Message.Headers).ContainsKey("x");
Check.That(response.Message.Headers["x"]).Contains("text/plain");
Check.That(response.Message.Headers["x"]).Contains("http://localhost/foo");
}
[Theory(Skip = "WireMockList is not supported by Scriban")]
@@ -322,16 +322,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, body, new Dictionary<string, string[]> { { "Content-Type", new[] { "text/plain" } } });
var response = Response.Create().WithHeader("x", "{{request.Headers[\"Content-Type\"]}}", "{{request.Url}}").WithBody("test").WithTransformer(transformerType);
var responseBuilder = Response.Create().WithHeader("x", "{{request.Headers[\"Content-Type\"]}}", "{{request.Url}}").WithBody("test").WithTransformer(transformerType);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("test");
Check.That(responseMessage.Headers).ContainsKey("x");
Check.That(responseMessage.Headers["x"]).Contains("text/plain");
Check.That(responseMessage.Headers["x"]).Contains("http://localhost/foo");
Check.That(response.Message.BodyData.BodyAsString).Equals("test");
Check.That(response.Message.Headers).ContainsKey("x");
Check.That(response.Message.Headers["x"]).Contains("text/plain");
Check.That(response.Message.Headers["x"]).Contains("http://localhost/foo");
}
[Theory]
@@ -348,15 +348,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
};
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBody("test {{request.Origin}} {{request.Port}} {{request.Protocol}} {{request.Host}}")
.WithTransformer(transformerType);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("test http://localhost:1234 1234 http localhost");
Check.That(response.Message.BodyData.BodyAsString).Equals("test http://localhost:1234 1234 http localhost");
}
[Theory]
@@ -375,15 +375,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo_object"), "POST", ClientIp, bodyData);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBodyAsJson(new { x = "test {{request.Path}}" })
.WithTransformer(transformerType);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(JsonConvert.SerializeObject(responseMessage.BodyData.BodyAsJson)).Equals("{\"x\":\"test /foo_object\"}");
Check.That(JsonConvert.SerializeObject(response.Message.BodyData.BodyAsJson)).Equals("{\"x\":\"test /foo_object\"}");
}
[Theory]
@@ -402,15 +402,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo_array"), "POST", ClientIp, bodyData);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBodyAsJson(new[] { "first", "{{request.path}}", "{{request.bodyAsJson.a}}", "{{request.bodyAsJson.b}}", "last" })
.WithTransformer(transformerType);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(JsonConvert.SerializeObject(responseMessage.BodyData.BodyAsJson)).Equals("[\"first\",\"/foo_array\",\"test 1\",\"test 2\",\"last\"]");
Check.That(JsonConvert.SerializeObject(response.Message.BodyData.BodyAsJson)).Equals("[\"first\",\"/foo_array\",\"test 1\",\"test 2\",\"last\"]");
}
[Fact]
@@ -419,15 +419,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost/foo?MyUniqueNumber=1"), "GET", ClientIp);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithTransformer()
.WithBodyFromFile(@"c:\\{{request.query.MyUniqueNumber}}\\test.xml");
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsFile).Equals(@"c:\1\test.xml");
Check.That(response.Message.BodyData.BodyAsFile).Equals(@"c:\1\test.xml");
}
[Theory(Skip = @"Does not work in Scriban --> c:\\[""1""]\\test.xml")]
@@ -438,15 +438,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign
var request = new RequestMessage(new UrlDetails("http://localhost/foo?MyUniqueNumber=1"), "GET", ClientIp);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithTransformer(transformerType)
.WithBodyFromFile(@"c:\\{{request.query.MyUniqueNumber}}\\test.xml");
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsFile).Equals(@"c:\1\test.xml");
Check.That(response.Message.BodyData.BodyAsFile).Equals(@"c:\1\test.xml");
}
[Theory]
@@ -463,17 +463,17 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost/foo?MyUniqueNumber=1"), "GET", ClientIp);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithTransformer(transformerType, true)
.WithBodyFromFile(@"c:\\{{request.query.MyUniqueNumber}}\\test.xml");
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(responseMessage.BodyData.BodyAsFile).Equals(@"c:\1\test.xml");
Check.That(responseMessage.BodyData.DetectedBodyType).Equals(BodyType.String);
Check.That(responseMessage.BodyData.BodyAsString).Equals("<xml MyUniqueNumber=\"1\"></xml>");
Check.That(response.Message.BodyData.BodyAsFile).Equals(@"c:\1\test.xml");
Check.That(response.Message.BodyData.DetectedBodyType).Equals(BodyType.String);
Check.That(response.Message.BodyData.BodyAsString).Equals("<xml MyUniqueNumber=\"1\"></xml>");
}
[Theory]
@@ -492,15 +492,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo_object"), "POST", ClientIp, bodyData);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBodyAsJson("test")
.WithTransformer(transformerType);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(JsonConvert.SerializeObject(responseMessage.BodyData.BodyAsJson)).Equals("\"test\"");
Check.That(JsonConvert.SerializeObject(response.Message.BodyData.BodyAsJson)).Equals("\"test\"");
}
[Fact(Skip = "todo...")]
@@ -516,15 +516,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo_object"), "POST", ClientIp, bodyData);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBodyAsJson("{{{request.BodyAsJson}}}")
.WithTransformer();
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(JsonConvert.SerializeObject(responseMessage.BodyData.BodyAsJson)).Equals("{\"name\":\"WireMock\"}");
Check.That(JsonConvert.SerializeObject(response.Message.BodyData.BodyAsJson)).Equals("{\"name\":\"WireMock\"}");
}
[Theory(Skip = "{{{ }}} Does not work in Scriban")]
@@ -542,15 +542,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo_object"), "POST", ClientIp, bodyData);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBodyAsJson("{{{request.BodyAsJson}}}")
.WithTransformer(transformerType);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
Check.That(JsonConvert.SerializeObject(responseMessage.BodyData.BodyAsJson)).Equals("{\"name\":\"WireMock\"}");
Check.That(JsonConvert.SerializeObject(response.Message.BodyData.BodyAsJson)).Equals("{\"name\":\"WireMock\"}");
}
[Theory]
@@ -570,16 +570,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo_object"), "POST", ClientIp, bodyData);
var response = Response.Create()
var responseBuilder = Response.Create()
.WithBody("{{request.Body}}", BodyDestinationFormat.SameAsSource, enc)
.WithTransformer(transformerType);
// Act
var responseMessage = await response.ProvideResponseAsync(request, _settings);
var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert
responseMessage.BodyData.BodyAsString.Should().Be(text);
responseMessage.BodyData.Encoding.Should().Be(enc);
response.Message.BodyData.BodyAsString.Should().Be(text);
response.Message.BodyData.Encoding.Should().Be(enc);
}
}
}

1110
test/WireMock.Net.Tests/WireMockAdminApiTests.cs
View File

File diff suppressed because it is too large Load Diff