starred/WireMock.Net
1
0
Fork 0
mirror of https://github.com/wiremock/WireMock.Net.git synced 2026-04-23 17:28:55 +02:00
Code Issues 32 Packages Projects Releases 10 Wiki Activity

Version 2.x (#1359)

Browse Source 
* Version 2.x

* Setup .NET 9

* 12

* cleanup some #if for NETSTANDARD1_3

* cleanup + fix tests for net8

* openapi

* NO ConfigureAwait(false) + cleanup

* .

* #endif

* HashSet

* WireMock.Net.NUnit

* HttpContext

* Add WebSockets (#1423)

* Add WebSockets

* Add tests

* fix

* more tests

* Add tests

* ...

* remove IOwin

* -

* tests

* fluent

* ok

* match

* .

* byte[]

* x

* func

* func

* byte

* trans

* ...

* frameworks.........

* jmes

* xxx

* sc

* using var httpClient = new HttpClient();

* usings

* maxRetries

* up

* xunit v3

* ct

* ---

* ct

* ct2

* T Unit

* WireMock.Net.TUnitTests / 10

* t unit first

* --project

* no tunit

* t2

* --project

* --project

* ci -  --project

* publish ./test/wiremock-coverage.xml

* windows

* .

* log

* ...

* log

* goed

* BodyType

* .

* .

* --scenario

* ...

* pact

* ct

* .

* WireMock.Net.RestClient.AwesomeAssertions (#1427)

* WireMock.Net.RestClient.AwesomeAssertions

* ok

* atpath

* fix test

* sonar fixes

* ports

* proxy test

* FIX?

* ---

* await Task.Delay(100, _ct);

* ?

* --project

* Aspire: use IDistributedApplicationEventingSubscriber (#1428)

* broadcast

* ok

* more tsts

* .

* Collection

* up

* .

* 2

* remove nfluent

* <VersionPrefix>2.0.0-preview-02</VersionPrefix>

* ...

* .

* nuget icon

* .

* <PackageReference Include="JmesPath.Net" Version="1.1.0" />

* x

* 500

* .

* fix some warnings

* ws
This commit is contained in:
Stef Heyenrath
2026-03-11 17:02:47 +01:00
committed by GitHub
parent d6e19532bc
commit a292f28dda
521 changed files with 79740 additions and 5246 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,12 +1,11 @@
// Copyright © WireMock.Net
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Moq;
using NFluent;
using WireMock.Models;
using WireMock.ResponseBuilders;
using WireMock.Settings;
using Xunit;
namespace WireMock.Net.Tests.ResponseBuilders;
@@ -25,9 +24,9 @@ public class ResponseCreateTests
var responseBuilder = Response.Create(() => responseMessage);
// Act
var response = await responseBuilder.ProvideResponseAsync(mapping, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(mapping, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message).Equals(responseMessage);
response.Message.Should().Be(responseMessage);
}
}
}

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

@@ -1,110 +1,108 @@
// Copyright © WireMock.Net
using System.IO;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using FluentAssertions;
using WireMock.RequestBuilders;
using WireMock.ResponseBuilders;
using WireMock.Server;
using Xunit;
namespace WireMock.Net.Tests.ResponseBuilders
namespace WireMock.Net.Tests.ResponseBuilders;
public class ResponseWithBodyFromFileTests
{
public class ResponseWithBodyFromFileTests
private readonly CancellationToken _ct = TestContext.Current.CancellationToken;
[Fact]
public async Task Response_ProvideResponse_WithBodyFromFile_AbsolutePath()
{
[Fact]
public async Task Response_ProvideResponse_WithBodyFromFile_AbsolutePath()
{
// Arrange
var server = WireMockServer.Start();
string path = Path.Combine(Directory.GetCurrentDirectory(), "__admin", "mappings", "MyXmlResponse.xml");
// Arrange
var server = WireMockServer.Start();
string path = Path.Combine(Directory.GetCurrentDirectory(), "__admin", "mappings", "MyXmlResponse.xml");
server
.Given(
Request
.Create()
.UsingGet()
.WithPath("/v1/content")
)
.RespondWith(
Response
.Create()
.WithStatusCode(HttpStatusCode.OK)
.WithHeader("Content-Type", "application/xml")
.WithBodyFromFile(path)
);
server
.Given(
Request
.Create()
.UsingGet()
.WithPath("/v1/content")
)
.RespondWith(
Response
.Create()
.WithStatusCode(HttpStatusCode.OK)
.WithHeader("Content-Type", "application/xml")
.WithBodyFromFile(path)
);
// Act
var response = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + "/v1/content").ConfigureAwait(false);
// Act
var response = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + "/v1/content", _ct);
// Assert
response.Should().Contain("<hello>world</hello>");
// Assert
response.Should().Contain("<hello>world</hello>");
server.Stop();
}
server.Stop();
}
[Fact]
public async Task Response_ProvideResponse_WithBodyFromFile_InSubDirectory()
{
// Arrange
var server = WireMockServer.Start();
string path = @"subdirectory/MyXmlResponse.xml";
[Fact]
public async Task Response_ProvideResponse_WithBodyFromFile_InSubDirectory()
{
// Arrange
var server = WireMockServer.Start();
string path = @"subdirectory/MyXmlResponse.xml";
server
.Given(
Request
.Create()
.UsingGet()
.WithPath("/v1/content")
)
.RespondWith(
Response
.Create()
.WithStatusCode(HttpStatusCode.OK)
.WithHeader("Content-Type", "application/xml")
.WithBodyFromFile(path)
);
server
.Given(
Request
.Create()
.UsingGet()
.WithPath("/v1/content")
)
.RespondWith(
Response
.Create()
.WithStatusCode(HttpStatusCode.OK)
.WithHeader("Content-Type", "application/xml")
.WithBodyFromFile(path)
);
// Act
var response = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + "/v1/content").ConfigureAwait(false);
// Act
using var httpClient = new HttpClient();
var response = await httpClient.GetStringAsync("http://localhost:" + server.Ports[0] + "/v1/content", _ct);
// Assert
response.Should().Contain("<hello>world</hello>");
// Assert
response.Should().Contain("<hello>world</hello>");
server.Stop();
}
server.Stop();
}
[Fact]
public async Task Response_ProvideResponse_WithBodyFromFile_InAdminMappingFolder()
{
// Arrange
var server = WireMockServer.Start();
string path = @"MyXmlResponse.xml";
[Fact]
public async Task Response_ProvideResponse_WithBodyFromFile_InAdminMappingFolder()
{
// Arrange
var server = WireMockServer.Start();
string path = @"MyXmlResponse.xml";
server
.Given(
Request
.Create()
.UsingGet()
.WithPath("/v1/content")
)
.RespondWith(
Response
.Create()
.WithStatusCode(HttpStatusCode.OK)
.WithHeader("Content-Type", "application/xml")
.WithBodyFromFile(path)
);
server
.Given(
Request
.Create()
.UsingGet()
.WithPath("/v1/content")
)
.RespondWith(
Response
.Create()
.WithStatusCode(HttpStatusCode.OK)
.WithHeader("Content-Type", "application/xml")
.WithBodyFromFile(path)
);
// Act
var response = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + "/v1/content").ConfigureAwait(false);
// Act
var response = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + "/v1/content", _ct);
// Assert
response.Should().Contain("<hello>world</hello>");
// Assert
response.Should().Contain("<hello>world</hello>");
server.Stop();
}
server.Stop();
}
}

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

@@ -1,20 +1,17 @@
// Copyright © WireMock.Net
using System;
using System.Text;
using System.Threading.Tasks;
using FluentAssertions;
using JsonConverter.Newtonsoft.Json;
using Microsoft.AspNetCore.Http;
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;
@@ -47,15 +44,15 @@ public class ResponseWithBodyTests
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, body);
var responseBuilder = Response.Create().WithBody(new byte[] { 48, 49 }, BodyDestinationFormat.String, Encoding.ASCII);
var responseBuilder = Response.Create().WithBody([48, 49], BodyDestinationFormat.String, Encoding.ASCII);
// act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// then
Check.That(response.Message.BodyData.BodyAsString).Equals("01");
Check.That(response.Message.BodyData.BodyAsBytes).IsNull();
Check.That(response.Message.BodyData.Encoding).Equals(Encoding.ASCII);
response.Message.BodyData.BodyAsString.Should().Be("01");
response.Message.BodyData.BodyAsBytes.Should().BeNull();
response.Message.BodyData.Encoding.Should().Be(Encoding.ASCII);
}
[Fact]
@@ -69,15 +66,15 @@ public class ResponseWithBodyTests
};
var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, body);
var responseBuilder = Response.Create().WithBody(new byte[] { 48, 49 }, BodyDestinationFormat.SameAsSource, Encoding.ASCII);
var responseBuilder = Response.Create().WithBody([48, 49], BodyDestinationFormat.SameAsSource, Encoding.ASCII);
// act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// then
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();
response.Message.BodyData.BodyAsBytes.Should().ContainInOrder([48, 49]);
response.Message.BodyData.BodyAsString.Should().BeNull();
response.Message.BodyData.Encoding.Should().BeNull();
}
[Fact]
@@ -94,11 +91,11 @@ public class ResponseWithBodyTests
var responseBuilder = Response.Create().WithBody("test", null, Encoding.ASCII);
// act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// then
Check.That(response.Message.BodyData.BodyAsString).Equals("test");
Check.That(response.Message.BodyData.Encoding).Equals(Encoding.ASCII);
response.Message.BodyData.BodyAsString.Should().Be("test");
response.Message.BodyData.Encoding.Should().Be(Encoding.ASCII);
}
[Fact]
@@ -116,11 +113,11 @@ public class ResponseWithBodyTests
var responseBuilder = Response.Create().WithBodyAsJson(x, Encoding.ASCII);
// act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// then
Check.That(response.Message.BodyData.BodyAsJson).Equals(x);
Check.That(response.Message.BodyData.Encoding).Equals(Encoding.ASCII);
response.Message.BodyData.BodyAsJson.Should().Be(x);
response.Message.BodyData.Encoding.Should().Be(Encoding.ASCII);
}
[Fact]
@@ -132,13 +129,13 @@ public class ResponseWithBodyTests
var responseBuilder = Response.Create().WithBody("r", BodyDestinationFormat.SameAsSource, Encoding.ASCII);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
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);
response.Message.BodyData.BodyAsBytes.Should().BeNull();
response.Message.BodyData.BodyAsJson.Should().BeNull();
response.Message.BodyData.BodyAsString.Should().Be("r");
response.Message.BodyData.Encoding.Should().Be(Encoding.ASCII);
}
[Fact]
@@ -150,13 +147,13 @@ public class ResponseWithBodyTests
var responseBuilder = Response.Create().WithBody("r", BodyDestinationFormat.Bytes, Encoding.ASCII);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
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);
response.Message.BodyData.BodyAsString.Should().BeNull();
response.Message.BodyData.BodyAsJson.Should().BeNull();
response.Message.BodyData.BodyAsBytes.Should().NotBeNull();
response.Message.BodyData.Encoding.Should().Be(Encoding.ASCII);
}
[Fact]
@@ -168,13 +165,13 @@ public class ResponseWithBodyTests
var responseBuilder = Response.Create().WithBody("{ \"value\": 42 }", BodyDestinationFormat.Json, Encoding.ASCII);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
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);
response.Message.BodyData!.BodyAsString.Should().BeNull();
response.Message.BodyData.BodyAsBytes.Should().BeNull();
((int)((JObject)response.Message.BodyData.BodyAsJson)["value"]!).Should().Be(42);
response.Message.BodyData.Encoding.Should().Be(Encoding.ASCII);
}
[Fact]
@@ -192,11 +189,11 @@ public class ResponseWithBodyTests
var responseBuilder = Response.Create().WithBodyAsJson(x, true);
// act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// then
Check.That(response.Message.BodyData.BodyAsJson).Equals(x);
Check.That(response.Message.BodyData.BodyAsJsonIndented).IsEqualTo(true);
response.Message.BodyData.BodyAsJson.Should().Be(x);
response.Message.BodyData.BodyAsJsonIndented.Should().Be(true);
}
[Fact]
@@ -214,7 +211,7 @@ public class ResponseWithBodyTests
var responseBuilder = Response.Create().WithBodyAsJson(requestMessage => responseBody);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
response.Message.BodyData!.BodyAsJson.Should().BeEquivalentTo(responseBody);
@@ -235,7 +232,7 @@ public class ResponseWithBodyTests
var responseBuilder = Response.Create().WithBodyAsJson(requestMessage => Task.FromResult(responseBody));
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
response.Message.BodyData!.BodyAsJson.Should().BeEquivalentTo(responseBody);
@@ -257,19 +254,19 @@ public class ResponseWithBodyTests
.WithTransformer();
// Act
var response1 = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request1, _settings).ConfigureAwait(false);
var response2 = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request2, _settings).ConfigureAwait(false);
var response1 = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request1, _settings);
var response2 = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request2, _settings);
// Assert
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);
((JToken)response1.Message.BodyData.BodyAsJson).SelectToken("id")?.Value<int>().Should().Be(request1Id);
response1.Message.BodyData.BodyAsBytes.Should().BeNull();
response1.Message.BodyData.BodyAsString.Should().BeNull();
response1.Message.StatusCode.Should().Be(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);
((JToken)response2.Message.BodyData.BodyAsJson).SelectToken("id")?.Value<int>().Should().Be(request2Id);
response2.Message.BodyData.BodyAsBytes.Should().BeNull();
response2.Message.BodyData.BodyAsString.Should().BeNull();
response2.Message.StatusCode.Should().Be(200);
}
[Fact]
@@ -282,10 +279,10 @@ public class ResponseWithBodyTests
var responseBuilder = Response.Create().WithStatusCode(200).WithBody(fileContents);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request1, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request1, _settings);
Check.That(response.Message.StatusCode).IsEqualTo(200);
Check.That(response.Message.BodyData.BodyAsString).Contains(fileContents);
response.Message.StatusCode.Should().Be(200);
response.Message.BodyData.BodyAsString.Should().Contain(fileContents);
}
[Fact]
@@ -298,10 +295,10 @@ public class ResponseWithBodyTests
var responseBuilder = Response.Create().WithStatusCode(200).WithBody(fileContents);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request1, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request1, _settings);
Check.That(response.Message.StatusCode).IsEqualTo(200);
Check.That(response.Message.BodyData.BodyAsString).Contains(fileContents);
response.Message.StatusCode.Should().Be(200);
response.Message.BodyData.BodyAsString.Should().Contain(fileContents);
}
[Fact]
@@ -314,10 +311,10 @@ public class ResponseWithBodyTests
var responseBuilder = Response.Create().WithStatusCode(200).WithBody("File deleted.");
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request1, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request1, _settings);
Check.That(response.Message.StatusCode).IsEqualTo(200);
Check.That(response.Message.BodyData?.BodyAsString).Contains("File deleted.");
response.Message.StatusCode.Should().Be(200);
response.Message.BodyData?.BodyAsString.Should().Contain("File deleted.");
}
[Fact]
@@ -334,13 +331,12 @@ public class ResponseWithBodyTests
var responseBuilder = Response.Create().WithBody(new { foo = "< > & ' 😀 👍 ❤️", n = 42 }, new NewtonsoftJsonConverter());
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
response.Message.BodyData!.BodyAsString.Should().Be("""{"foo":"< > & ' 😀 👍 ❤️","n":42}""");
}
#if !(NET451 || NET452 || NET461)
[Fact]
public async Task Response_ProvideResponse_WithBody_SystemTextJsonConverter()
{
@@ -355,10 +351,9 @@ public class ResponseWithBodyTests
var responseBuilder = Response.Create().WithBody(new { foo = "< > & ' 😀 👍 ❤️", n = 42 }, new JsonConverter.System.Text.Json.SystemTextJsonConverter());
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
response.Message.BodyData!.BodyAsString.Should().Be("""{"foo":"\u003C \u003E \u0026 \u0027 \uD83D\uDE00 \uD83D\uDC4D \u2764\uFE0F","n":42}""");
}
#endif
}

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

@@ -1,20 +1,16 @@
// Copyright © WireMock.Net
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using FluentAssertions;
using Microsoft.AspNetCore.Http;
using Moq;
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;
@@ -48,16 +44,16 @@ public class ResponseWithCallbackTests
.WithBody(req => $"path: {req.Path}");
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
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");
response.Message.BodyData.BodyAsString.Should().Be("path: /test");
response.Message.BodyData.BodyAsBytes.Should().BeNull();
response.Message.BodyData.BodyAsJson.Should().BeNull();
response.Message.BodyData.Encoding.CodePage.Should().Be(Encoding.UTF8.CodePage);
response.Message.StatusCode.Should().Be(500);
response.Message.Headers["H1"].ToString().Should().Be("X1");
response.Message.Headers["H2"].ToString().Should().Be("X2");
}
[Fact]
@@ -77,8 +73,8 @@ public class ResponseWithCallbackTests
});
// Act (2x)
var response1 = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response2 = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response1 = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
var response2 = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
response1.Message.BodyData!.BodyAsString.Should().Be("x");
@@ -104,8 +100,8 @@ public class ResponseWithCallbackTests
});
// Act (2x)
var response1 = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response2 = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response1 = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
var response2 = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
response1.Message.BodyData!.BodyAsString.Should().Be("x");
@@ -126,21 +122,21 @@ public class ResponseWithCallbackTests
.WithHeader("H2", "X2")
.WithBody(async req =>
{
await Task.Delay(1).ConfigureAwait(false);
await Task.Delay(1);
return $"path: {req.Path}";
});
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
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");
response.Message.BodyData.BodyAsString.Should().Be("path: /test");
response.Message.BodyData.BodyAsBytes.Should().BeNull();
response.Message.BodyData.BodyAsJson.Should().BeNull();
response.Message.BodyData.Encoding.CodePage.Should().Be(Encoding.UTF8.CodePage);
response.Message.StatusCode.Should().Be(500);
response.Message.Headers["H1"].ToString().Should().Be("X1");
response.Message.Headers["H2"].ToString().Should().Be("X2");
}
[Fact]
@@ -165,7 +161,7 @@ public class ResponseWithCallbackTests
});
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, requestMessage, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), requestMessage, _settings);
// Assert
response.Message.BodyData.BodyAsString.Should().Be("/fooBar");
@@ -189,7 +185,7 @@ public class ResponseWithCallbackTests
});
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, requestMessage, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), requestMessage, _settings);
// Assert
response.Message.BodyData.BodyAsString.Should().Be("/fooBar");
@@ -218,7 +214,7 @@ public class ResponseWithCallbackTests
});
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, requestMessage, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), requestMessage, _settings);
// Assert
response.Message.BodyData.BodyAsString.Should().Be("/fooBar");
@@ -250,7 +246,7 @@ public class ResponseWithCallbackTests
.WithHeader(header, "Stef");
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, requestMessage, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), requestMessage, _settings);
// Assert
response.Message.BodyData.BodyAsString.Should().Be("/fooBar");
@@ -276,7 +272,7 @@ public class ResponseWithCallbackTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, requestMessage, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), requestMessage, _settings);
// Assert
response.Message.BodyData.BodyAsString.Should().Be("/fooBar");
@@ -311,9 +307,10 @@ public class ResponseWithCallbackTests
});
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, requestMessage, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), requestMessage, _settings);
// Assert
response.Message.Headers![headerKey].Should().Contain("extra");
}
}
}

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

@@ -1,12 +1,10 @@
// Copyright © WireMock.Net
using System.Threading.Tasks;
using FluentAssertions;
using Microsoft.AspNetCore.Http;
using Moq;
using WireMock.Models;
using WireMock.ResponseBuilders;
using WireMock.Settings;
using Xunit;
namespace WireMock.Net.Tests.ResponseBuilders;
@@ -32,7 +30,7 @@ public class ResponseWithFaultTests
// Act
var responseBuilder = Response.Create().WithFault(faultType);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
response.Message.FaultType.Should().Be(faultType);
@@ -48,7 +46,7 @@ public class ResponseWithFaultTests
// Act
var responseBuilder = Response.Create().WithFault(faultType, percentage);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
response.Message.FaultType.Should().Be(faultType);

15
test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHandlebarsDateTimeTests.cs
View File

@@ -1,8 +1,6 @@
// Copyright © WireMock.Net
using System;
using System.Threading.Tasks;
using FluentAssertions;
using Microsoft.AspNetCore.Http;
using Moq;
using Newtonsoft.Json.Linq;
using WireMock.Handlers;
@@ -10,7 +8,6 @@ using WireMock.Models;
using WireMock.ResponseBuilders;
using WireMock.Settings;
using WireMock.Types;
using Xunit;
namespace WireMock.Net.Tests.ResponseBuilders;
@@ -47,7 +44,7 @@ public class ResponseWithHandlebarsDateTimeTests
.WithTransformer(options);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
var jObject = JObject.FromObject(response.Message.BodyData!.BodyAsJson!);
@@ -71,7 +68,7 @@ public class ResponseWithHandlebarsDateTimeTests
.WithTransformer(options);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
var jObject = JObject.FromObject(response.Message.BodyData!.BodyAsJson!);
@@ -94,7 +91,7 @@ public class ResponseWithHandlebarsDateTimeTests
.WithTransformer(options);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
var jObject = JObject.FromObject(response.Message.BodyData!.BodyAsJson!);
@@ -112,7 +109,7 @@ public class ResponseWithHandlebarsDateTimeTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
response.Message.BodyData!.BodyAsString.Should().Contain($"DateTimeYear = \"{DateTime.Now.Year}\"");
@@ -137,7 +134,7 @@ public class ResponseWithHandlebarsDateTimeTests
.WithTransformer(options);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
var jObject = JObject.FromObject(response.Message.BodyData!.BodyAsJson!);

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

@@ -1,18 +1,14 @@
// Copyright © WireMock.Net
using System;
using System.Threading.Tasks;
using FluentAssertions;
using HandlebarsDotNet;
using Microsoft.AspNetCore.Http;
using Moq;
using Newtonsoft.Json.Linq;
using NFluent;
using WireMock.Handlers;
using WireMock.Models;
using WireMock.ResponseBuilders;
using WireMock.Settings;
using WireMock.Types;
using Xunit;
namespace WireMock.Net.Tests.ResponseBuilders;
@@ -55,11 +51,11 @@ public class ResponseWithHandlebarsFileTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
var j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["Data"].Value<string>()).Equals("abc");
j["Data"].Value<string>().Should().Be("abc");
// Verify
_filesystemHandlerMock.Verify(fs => fs.ReadResponseBodyAsString("x.json"), Times.Once);
@@ -80,11 +76,11 @@ public class ResponseWithHandlebarsFileTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
var j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["Data"].Value<string>()).Equals("abc");
j["Data"].Value<string>().Should().Be("abc");
// Verify
_filesystemHandlerMock.Verify(fs => fs.ReadResponseBodyAsString("x.json"), Times.Once);
@@ -105,7 +101,8 @@ public class ResponseWithHandlebarsFileTests
.WithTransformer();
// Act
Check.ThatAsyncCode(() => responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings)).Throws<HandlebarsException>();
Func<Task> act = () => responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
act.Should().ThrowAsync<HandlebarsException>();
// Verify
_filesystemHandlerMock.Verify(fs => fs.ReadResponseBodyAsString(It.IsAny<string>()), Times.Never);
@@ -127,7 +124,7 @@ public class ResponseWithHandlebarsFileTests
.WithTransformer();
// Act
Func<Task> action = () => responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, settings);
Func<Task> action = () => responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, settings);
action.Should().ThrowAsync<HandlebarsRuntimeException>();

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

@@ -1,15 +1,14 @@
// Copyright © WireMock.Net
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Moq;
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;
@@ -40,9 +39,9 @@ public class ResponseWithHandlebarsHelpersTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(new Mock<IMapping>().Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(Mock.Of<IMapping>(), Mock.Of<HttpContext>(), request, _settings);
// assert
Check.That(response.Message.BodyData.BodyAsString).Equals("ABC");
response.Message.BodyData.BodyAsString.Should().Be("ABC");
}
}
}

13
test/WireMock.Net.Tests/ResponseBuilders/ResponseWithHandlebarsHumanizerTests.cs
View File

@@ -1,15 +1,13 @@
// Copyright © WireMock.Net
using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
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;
@@ -44,10 +42,11 @@ public class ResponseWithHandlebarsHumanizerTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["Text"].Value<string>()).IsEqualTo("Pascal case input string is turned into sentence");
j["Text"].Value<string>().Should().Be("Pascal case input string is turned into sentence");
}
}
}

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

@@ -1,20 +1,18 @@
// Copyright © WireMock.Net
using System;
using System.Text;
using System.Threading.Tasks;
using FluentAssertions;
using HandlebarsDotNet;
using Microsoft.AspNetCore.Http;
using Moq;
using Newtonsoft.Json;
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;
@@ -82,12 +80,12 @@ public class ResponseWithHandlebarsJsonPathTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["x"]).IsNotNull();
Check.That(j["x"]["Name"].ToString()).Equals("Acme Co");
j["x"].Should().NotBeNull();
j["x"]["Name"].ToString().Should().Be("Acme Co");
}
[Fact]
@@ -108,11 +106,11 @@ public class ResponseWithHandlebarsJsonPathTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson!);
Check.That(j["x"].Value<long>()).Equals(99);
var j = JObject.FromObject(response.Message.BodyData!.BodyAsJson!);
j["x"]?.Value<long>().Should().Be(99);
}
[Fact]
@@ -162,10 +160,10 @@ public class ResponseWithHandlebarsJsonPathTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
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}}}");
response.Message.BodyData!.BodyAsString.Should().Be($"{{{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]
@@ -215,10 +213,10 @@ public class ResponseWithHandlebarsJsonPathTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
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}}}");
response.Message.BodyData.BodyAsString.Should().Be($"{{{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]
@@ -268,10 +266,10 @@ public class ResponseWithHandlebarsJsonPathTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message.BodyData.BodyAsString).Equals("%0:Anvil%%1:Elbow Grease%");
response.Message.BodyData.BodyAsString.Should().Be("%0:Anvil%%1:Elbow Grease%");
}
[Fact]
@@ -321,10 +319,10 @@ public class ResponseWithHandlebarsJsonPathTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message.BodyData.BodyAsString).Equals("%0:Anvil%%1:Elbow Grease%");
response.Message.BodyData.BodyAsString.Should().Be("%0:Anvil%%1:Elbow Grease%");
}
[Fact]
@@ -350,7 +348,8 @@ public class ResponseWithHandlebarsJsonPathTests
.WithTransformer();
// Act
Check.ThatAsyncCode(() => responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings)).Throws<ArgumentNullException>();
Func<Task> act = () => responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
act.Should().ThrowAsync<HandlebarsException>();
}
[Fact]
@@ -376,7 +375,7 @@ public class ResponseWithHandlebarsJsonPathTests
.WithBodyFromFile("c:\\\\{{JsonPath.SelectToken request.body \"$.MyUniqueNumber\" }}\\test.json");
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
response.Message.BodyData?.BodyAsFile.Should().Be(@"c:\1\test.json");

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

@@ -1,19 +1,15 @@
// Copyright © WireMock.Net
using System;
using System.Threading.Tasks;
using FluentAssertions;
using HandlebarsDotNet;
using Microsoft.AspNetCore.Http;
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;
@@ -47,12 +43,12 @@ public class ResponseWithHandlebarsLinqTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["x"]).IsNotNull();
Check.That(j["x"].ToString()).Equals("/pathtest");
var j = JObject.FromObject(response.Message.BodyData!.BodyAsJson!);
j["x"].Should().NotBeNull();
j["x"]?.ToString().Should().Be("/pathtest");
}
[Fact(Skip = "DynamicLinq")]
@@ -77,12 +73,11 @@ public class ResponseWithHandlebarsLinqTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["x"]).IsNotNull();
Check.That(j["x"].ToString()).Equals("Test_123");
var j = JObject.FromObject(response.Message.BodyData!.BodyAsJson!);
j["x"].Should().NotBeNull().And.Subject.ToString().Should().Be("Test_123");
}
[Fact(Skip = "DynamicLinq")]
@@ -107,12 +102,11 @@ public class ResponseWithHandlebarsLinqTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), 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 }");
var j = JObject.FromObject(response.Message.BodyData!.BodyAsJson!);
j["x"]?.ToString().Should().Be("{ N = Test_123, I = 9 }");
}
[Fact(Skip = "DynamicLinq")]
@@ -137,12 +131,11 @@ public class ResponseWithHandlebarsLinqTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), 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 }");
var j = JObject.FromObject(response.Message.BodyData!.BodyAsJson!);
j["x"]?.ToString().Should().Be("{ N = Test_123 }");
}
[Fact(Skip = "DynamicLinq")]
@@ -162,7 +155,10 @@ public class ResponseWithHandlebarsLinqTests
.WithTransformer();
// Act
Check.ThatAsyncCode(() => responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings)).Throws<ArgumentException>();
Func<Task> act = () => responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
act.Should().ThrowAsync<HandlebarsException>();
}
[Fact]
@@ -178,7 +174,10 @@ public class ResponseWithHandlebarsLinqTests
.WithTransformer();
// Act
Check.ThatAsyncCode(() => responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings)).Throws<HandlebarsException>();
Func<Task> act = () => responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
act.Should().ThrowAsync<HandlebarsException>();
}
[Fact]
@@ -202,7 +201,7 @@ public class ResponseWithHandlebarsLinqTests
.WithTransformer();
// Act
Func<Task> a = async () => await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
Func<Task> a = async () => await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
a.Should().ThrowAsync<HandlebarsException>();
@@ -229,9 +228,9 @@ public class ResponseWithHandlebarsLinqTests
.WithTransformer();
// Act
Func<Task> a = async () => await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
Func<Task> act = async () => await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
a.Should().ThrowAsync<HandlebarsException>();
act.Should().ThrowAsync<HandlebarsException>();
}
}

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

@@ -1,17 +1,13 @@
// Copyright © WireMock.Net
using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;
using Microsoft.AspNetCore.Http;
using Moq;
using Newtonsoft.Json.Linq;
using NFluent;
using WireMock.Handlers;
using WireMock.Models;
using WireMock.ResponseBuilders;
using WireMock.Settings;
using WireMock.Types;
using Xunit;
namespace WireMock.Net.Tests.ResponseBuilders;
@@ -49,13 +45,13 @@ public class ResponseWithHandlebarsRandomTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
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);
JObject j = JObject.FromObject(response.Message.BodyData!.BodyAsJson!);
j["Text"]?.Value<string>().Should().NotBeNullOrEmpty();
j["Integer"]?.Value<int>().Should().Be(1000);
j["Long"]?.Value<long>().Should().BeInRange(77777777, 99999999);
}
[Fact]
@@ -72,11 +68,11 @@ public class ResponseWithHandlebarsRandomTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["Value"].Type).IsEqualTo(JTokenType.Boolean);
JObject j = JObject.FromObject(response.Message.BodyData!.BodyAsJson!);
j["Value"]?.Type.Should().Be(JTokenType.Boolean);
}
[Theory]
@@ -95,7 +91,7 @@ public class ResponseWithHandlebarsRandomTests
.WithTransformer(options);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
var jObject = JObject.FromObject(response.Message.BodyData!.BodyAsJson!);
@@ -120,7 +116,7 @@ public class ResponseWithHandlebarsRandomTests
.WithTransformer(options);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
var jObject = JObject.FromObject(response.Message.BodyData!.BodyAsJson!);
@@ -142,7 +138,7 @@ public class ResponseWithHandlebarsRandomTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
var jObject = JObject.FromObject(response.Message.BodyData!.BodyAsJson!);
@@ -163,12 +159,12 @@ public class ResponseWithHandlebarsRandomTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
string value = j["StringValue"].Value<string>();
Check.That(new[] { "a", "b", "c" }.Contains(value)).IsTrue();
JObject j = JObject.FromObject(response.Message.BodyData!.BodyAsJson!);
var value = j["StringValue"]?.Value<string>();
new[] { "a", "b", "c" }.Should().Contain(value);
}
[Fact]
@@ -185,11 +181,11 @@ public class ResponseWithHandlebarsRandomTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["Integer"].Value<int>()).IsStrictlyGreaterThan(10000000).And.IsStrictlyLessThan(99999999);
JObject j = JObject.FromObject(response.Message.BodyData!.BodyAsJson!);
j["Integer"]?.Value<int>().Should().BeInRange(10000000, 99999999);
}
[Fact]
@@ -206,10 +202,10 @@ public class ResponseWithHandlebarsRandomTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
var j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
j["Long"].Value<long>().Should().BeInRange(1000000000, 9999999999);
var j = JObject.FromObject(response.Message.BodyData!.BodyAsJson!);
j["Long"]?.Value<long>().Should().BeInRange(1000000000, 9999999999);
}
}

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

@@ -1,16 +1,15 @@
// Copyright © WireMock.Net
using System;
using System.Threading.Tasks;
using HandlebarsDotNet;
using Microsoft.AspNetCore.Http;
using Moq;
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;
@@ -44,10 +43,10 @@ public class ResponseWithHandlebarsRegexTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// assert
Check.That(response.Message.BodyData.BodyAsString).Equals("abc");
response.Message.BodyData.BodyAsString.Should().Be("abc");
}
[Fact]
@@ -63,10 +62,10 @@ public class ResponseWithHandlebarsRegexTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// assert
Check.That(response.Message.BodyData.BodyAsString).Equals("");
response.Message.BodyData.BodyAsString.Should().Be("");
}
[Fact]
@@ -82,10 +81,10 @@ public class ResponseWithHandlebarsRegexTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// assert
Check.That(response.Message.BodyData.BodyAsString).Equals("5000-https");
response.Message.BodyData.BodyAsString.Should().Be("5000-https");
}
[Fact]
@@ -101,10 +100,10 @@ public class ResponseWithHandlebarsRegexTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// assert
Check.That(response.Message.BodyData.BodyAsString).Equals("");
response.Message.BodyData.BodyAsString.Should().Be("");
}
[Fact]
@@ -119,7 +118,10 @@ public class ResponseWithHandlebarsRegexTests
.WithBody("{{#Regex.Match request.bodyAsJson \"^(?<proto>\\w+)://[^/]+?(?<port>\\d+)/?\"}}{{/Regex.Match}}")
.WithTransformer();
// Act and Assert
Check.ThatAsyncCode(() => responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings)).Throws<ArgumentNullException>();
// Act
Func<Task> act = () => responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
act.Should().ThrowAsync<HandlebarsException>();
}
}
}

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

@@ -1,20 +1,14 @@
// Copyright © WireMock.Net
using System.Threading.Tasks;
using System.Xml;
using NFluent;
using Microsoft.AspNetCore.Http;
using Moq;
using WireMock.Handlers;
using WireMock.Models;
using WireMock.ResponseBuilders;
using WireMock.Settings;
using WireMock.Types;
using WireMock.Util;
using Xunit;
using Moq;
using WireMock.Handlers;
using FluentAssertions;
#if !NETSTANDARD1_3
using Wmhelp.XPath2;
#endif
namespace WireMock.Net.Tests.ResponseBuilders;
@@ -57,7 +51,7 @@ public class ResponseWithHandlebarsXPathTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
response.Message.BodyData!.BodyAsString.Should().Be("<response>abc</response>");
@@ -85,10 +79,10 @@ public class ResponseWithHandlebarsXPathTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message.BodyData.BodyAsString).IsEqualTo("abc");
response.Message.BodyData.BodyAsString.Should().Be("abc");
}
[Fact]
@@ -113,7 +107,7 @@ public class ResponseWithHandlebarsXPathTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
response.Message.BodyData!.BodyAsString.Should().Be("<response>abc,def,xyz</response>");
@@ -169,7 +163,7 @@ public class ResponseWithHandlebarsXPathTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
response.Message.BodyData!.BodyAsString.Should().Be("<response>0000083256</response>");
@@ -197,10 +191,10 @@ public class ResponseWithHandlebarsXPathTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message.BodyData.BodyAsString).IsEqualIgnoringCase("True");
response.Message.BodyData.BodyAsString.Should().BeEquivalentTo("True");
}
[Fact]
@@ -225,9 +219,10 @@ public class ResponseWithHandlebarsXPathTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message.BodyData.BodyAsString).IsEqualTo("a1");
response.Message.BodyData.BodyAsString.Should().Be("a1");
}
}
}

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

@@ -1,14 +1,12 @@
// Copyright © WireMock.Net
using Microsoft.AspNetCore.Http;
using Moq;
using Newtonsoft.Json.Linq;
using NFluent;
using System.Threading.Tasks;
using WireMock.Handlers;
using WireMock.Models;
using WireMock.ResponseBuilders;
using WireMock.Settings;
using Xunit;
namespace WireMock.Net.Tests.ResponseBuilders;
@@ -44,12 +42,12 @@ public class ResponseWithHandlebarsXegerTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
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();
j["Number"].Value<int>().Should().BeGreaterThan(1000).And.BeLessThan(9999);
j["Postcode"].Value<string>().Should().NotBeEmpty();
}
[Fact]
@@ -67,11 +65,11 @@ public class ResponseWithHandlebarsXegerTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
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();
var j = JObject.FromObject(response.Message.BodyData!.BodyAsJson!);
j["Number"]?.Value<int>().Should().BeGreaterThan(1000).And.BeLessThan(9999);
j["Postcode"]?.Value<string>().Should().NotBeEmpty();
}
}

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

@@ -1,14 +1,11 @@
// Copyright © WireMock.Net
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Moq;
using NFluent;
using WireMock.Models;
using WireMock.ResponseBuilders;
using WireMock.Settings;
using WireMock.Types;
using Xunit;
namespace WireMock.Net.Tests.ResponseBuilders;
@@ -35,10 +32,10 @@ public class ResponseWithHeadersTests
IResponseBuilder builder = Response.Create().WithHeader(headerName, headerValue);
// Act
var response = await builder.ProvideResponseAsync(_mappingMock.Object, requestMock, _settings).ConfigureAwait(false);
var response = await builder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), requestMock, _settings);
// Assert
Check.That(response.Message.Headers[headerName].ToString()).Equals(headerValue);
response.Message.Headers[headerName].ToString().Should().Be(headerValue);
}
[Theory]
@@ -51,10 +48,10 @@ public class ResponseWithHeadersTests
IResponseBuilder builder = Response.Create().WithHeader(headerName, headerValues);
// Act
var response = await builder.ProvideResponseAsync(_mappingMock.Object, requestMock, _settings).ConfigureAwait(false);
var response = await builder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), requestMock, _settings);
// Assert
Check.That(response.Message.Headers[headerName].ToArray()).Equals(headerValues);
response.Message.Headers[headerName].ToArray().Should().Equal(headerValues);
}
[Fact]
@@ -66,10 +63,10 @@ public class ResponseWithHeadersTests
var response = Response.Create().WithHeaders(headers);
// Act
var responseMessage = await response.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var responseMessage = await response.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(responseMessage.Message.Headers["h"]).ContainsExactly("x");
responseMessage.Message.Headers["h"].Should().ContainSingle("x");
}
[Fact]
@@ -81,10 +78,10 @@ public class ResponseWithHeadersTests
var responseBuilder = Response.Create().WithHeaders(headers);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message.Headers["h"]).ContainsExactly("x");
response.Message.Headers["h"].Should().ContainSingle("x");
}
[Fact]
@@ -96,9 +93,9 @@ public class ResponseWithHeadersTests
var builder = Response.Create().WithHeaders(headers);
// Act
var response = await builder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await builder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message.Headers["h"]).ContainsExactly("x");
response.Message.Headers["h"].Should().ContainSingle("x");
}
}

19
test/WireMock.Net.Tests/ResponseBuilders/ResponseWithProxyIntegrationTests.cs
View File

@@ -1,15 +1,10 @@
// Copyright © WireMock.Net
#if NET8_0_OR_GREATER
using System;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using FluentAssertions;
using AwesomeAssertions;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Hosting.Server;
@@ -22,13 +17,13 @@ using WireMock.RequestBuilders;
using WireMock.ResponseBuilders;
using WireMock.Server;
using WireMock.Settings;
using Xunit;
using Xunit.Abstractions;
namespace WireMock.Net.Tests.ResponseBuilders;
public sealed class ResponseWithProxyIntegrationTests(ITestOutputHelper output)
{
private readonly CancellationToken _ct = TestContext.Current.CancellationToken;
[Fact]
public async Task Response_UsingTextPlain()
{
@@ -51,12 +46,12 @@ public sealed class ResponseWithProxyIntegrationTests(ITestOutputHelper output)
content.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
// When
var response = await client.PatchAsync("/zipcode", content);
var response = await client.PatchAsync("/zipcode", content, _ct);
// Then
response.StatusCode.Should().Be(HttpStatusCode.OK);
response.Content.Headers.GetValues("Content-Type").Should().BeEquivalentTo("text/plain; charset=utf-8");
var result = await response.Content.ReadAsStringAsync();
var result = await response.Content.ReadAsStringAsync(_ct);
result.Should().Be("0123");
}
@@ -95,10 +90,10 @@ public sealed class ResponseWithProxyIntegrationTests(ITestOutputHelper output)
{
var started = new TaskCompletionSource();
var host = app.Services.GetRequiredService<IHostApplicationLifetime>();
host.ApplicationStarted.Register(() => started.SetResult());
host.ApplicationStarted.Register(started.SetResult);
_ = Task.Run(() => app.RunAsync());
await started.Task;
_disposable = new(() => host.StopApplication());
_disposable = new(host.StopApplication);
return this;
}

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

@@ -1,11 +1,8 @@
// Copyright © WireMock.Net
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Moq;
using NFluent;
using WireMock.Models;
using WireMock.RequestBuilders;
using WireMock.ResponseBuilders;
@@ -13,7 +10,6 @@ using WireMock.Server;
using WireMock.Settings;
using WireMock.Types;
using WireMock.Util;
using Xunit;
namespace WireMock.Net.Tests.ResponseBuilders;
@@ -56,13 +52,13 @@ public class ResponseWithProxyTests : IDisposable
var responseBuilder = Response.Create().WithProxy(_server.Urls[0]);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(request.ProxyUrl).IsNotNull();
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");
request.ProxyUrl.Should().NotBeNull();
response.Message.BodyData.BodyAsString.Should().Be(expectedBody);
response.Message.StatusCode.Should().Be(201);
response.Message.Headers["Content-Type"].ToString().Should().Be("application/json");
}
[Fact]
@@ -83,8 +79,10 @@ public class ResponseWithProxyTests : IDisposable
// Act
var request = new RequestMessage(new UrlDetails($"{_server.Urls[0]}/{_guid}"), "GET", ClientIp);
Func<Task> act = () => responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
Check.ThatAsyncCode(() => responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings)).Throws<HttpRequestException>();
// Assert
act.Should().ThrowAsync<HttpRequestException>();
}
public void Dispose()
@@ -92,4 +90,5 @@ public class ResponseWithProxyTests : IDisposable
_server?.Stop();
_server?.Dispose();
}
}
}

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

@@ -1,22 +1,13 @@
// Copyright © WireMock.Net
using System;
using System.Threading.Tasks;
using FluentAssertions;
using NFluent;
using WireMock.Models;
using WireMock.ResponseBuilders;
using WireMock.Settings;
using WireMock.Types;
using WireMock.Util;
using Xunit;
using WireMock.Handlers;
using Moq;
#if NET452
using Microsoft.Owin;
#else
using Microsoft.AspNetCore.Http;
#endif
namespace WireMock.Net.Tests.ResponseBuilders;
@@ -47,7 +38,7 @@ public class ResponseWithScribanTests
var responseBuilder = Response.Create().WithTransformer(TransformerType.ScribanDotLiquid);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
response.Message.BodyData.Should().BeNull();
@@ -69,9 +60,10 @@ public class ResponseWithScribanTests
.WithTransformer(TransformerType.Scriban);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message.BodyData.BodyAsString).Equals("test http://localhost/foo /foo POSt");
response.Message.BodyData.BodyAsString.Should().Be("test http://localhost/foo /foo POSt");
}
}

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

@@ -1,13 +1,11 @@
// Copyright © WireMock.Net
using FluentAssertions;
using Moq;
using System.Net;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Moq;
using WireMock.Models;
using WireMock.ResponseBuilders;
using WireMock.Settings;
using Xunit;
namespace WireMock.Net.Tests.ResponseBuilders;
@@ -42,7 +40,7 @@ public class ResponseWithStatusCodeTests
break;
}
var response = await responseBuilder.ProvideResponseAsync(new Mock<IMapping>().Object, request, _settingsMock.Object).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(Mock.Of<IMapping>(), Mock.Of<HttpContext>(), request, _settingsMock.Object);
// Assert
response.Message.StatusCode.Should().Be(expectedStatusCode);

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

@@ -1,28 +1,18 @@
// Copyright © WireMock.Net
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text;
using System.Threading.Tasks;
using FluentAssertions;
using Microsoft.AspNetCore.Http;
using Moq;
using Newtonsoft.Json;
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;
using System.Globalization;
using CultureAwareTesting.xUnit;
#if NET452
using Microsoft.Owin;
#else
using Microsoft.AspNetCore.Http;
#endif
namespace WireMock.Net.Tests.ResponseBuilders;
@@ -57,7 +47,7 @@ public class ResponseWithTransformerTests
var responseBuilder = Response.Create().WithTransformer(transformerType);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
response.Message.BodyData.Should().BeNull();
@@ -82,10 +72,10 @@ public class ResponseWithTransformerTests
.WithTransformer(transformerType);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message.BodyData!.BodyAsString).Equals("test http://localhost/foo /foo POSt");
response.Message.BodyData!.BodyAsString.Should().Be("test http://localhost/foo /foo POSt");
}
[Theory]
@@ -106,10 +96,10 @@ public class ResponseWithTransformerTests
.WithTransformer(transformerType);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
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");
response.Message.BodyData!.BodyAsString.Should().Be("url=http://localhost/a/b absoluteurl=http://localhost/wiremock/a/b path=/a/b absolutepath=/wiremock/a/b");
}
[Fact]
@@ -124,10 +114,10 @@ public class ResponseWithTransformerTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message.BodyData!.BodyAsString).Equals("a b wiremock");
response.Message.BodyData!.BodyAsString.Should().Be("a b wiremock");
}
[Theory]
@@ -146,11 +136,11 @@ public class ResponseWithTransformerTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
var json = (JObject)response.Message.BodyData!.BodyAsJson!;
Check.That(json["field"]!.Value<string>()).Equals(expected);
json["field"]!.Value<string>().Should().Be(expected);
}
[Theory(Skip = "Invalid token `OpenBracket`")]
@@ -167,10 +157,10 @@ public class ResponseWithTransformerTests
.WithTransformer(transformerType);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message.BodyData!.BodyAsString).Equals("a wiremock");
response.Message.BodyData!.BodyAsString.Should().Be("a wiremock");
}
[Fact]
@@ -189,10 +179,10 @@ public class ResponseWithTransformerTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message.BodyData!.BodyAsString).Equals("test keya=1,2 idx=1 idx=2 keyb=5");
response.Message.BodyData!.BodyAsString.Should().Be("test keya=1,2 idx=1 idx=2 keyb=5");
}
[Theory(Skip = "Invalid token `OpenBracket`")]
@@ -213,10 +203,10 @@ public class ResponseWithTransformerTests
.WithTransformer(transformerType);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message.BodyData!.BodyAsString).Equals("test keya=1 idx=1 idx=2 keyb=5");
response.Message.BodyData!.BodyAsString.Should().Be("test keya=1 idx=1 idx=2 keyb=5");
}
[Fact]
@@ -236,11 +226,11 @@ public class ResponseWithTransformerTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message.BodyData!.BodyAsString).Equals("test");
Check.That(response.Message.StatusCode).Equals("400");
response.Message.BodyData!.BodyAsString.Should().Be("test");
response.Message.StatusCode.Should().Be("400");
}
[Theory(Skip = "WireMockList is not supported by Scriban")]
@@ -262,11 +252,11 @@ public class ResponseWithTransformerTests
.WithTransformer(transformerType);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message.BodyData!.BodyAsString).Equals("test");
Check.That(response.Message.StatusCode).Equals("400");
response.Message.BodyData!.BodyAsString.Should().Be("test");
response.Message.StatusCode.Should().Be("400");
}
[Theory]
@@ -288,11 +278,11 @@ public class ResponseWithTransformerTests
.WithTransformer(transformerType);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message.BodyData!.BodyAsString).Equals("test");
Check.That(response.Message.StatusCode).Equals(null);
response.Message.BodyData!.BodyAsString.Should().Be("test");
response.Message.StatusCode.Should().Be(null);
}
[Fact]
@@ -309,12 +299,12 @@ public class ResponseWithTransformerTests
var responseBuilder = Response.Create().WithHeader("x", "{{request.headers.Content-Type}}").WithBody("test").WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message.BodyData!.BodyAsString).Equals("test");
Check.That(response.Message.Headers).ContainsKey("x");
Check.That(response.Message.Headers!["x"]).ContainsExactly("text/plain");
response.Message.BodyData!.BodyAsString.Should().Be("test");
response.Message.Headers.Should().ContainKey("x");
response.Message.Headers!["x"].Should().ContainSingle("text/plain");
}
[Fact]
@@ -334,12 +324,12 @@ public class ResponseWithTransformerTests
var responseBuilder = Response.Create().WithHeader("x", "{{mapping.Guid}}").WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
response.Message.Headers.Should().NotBeNull();
Check.That(response.Message.Headers).ContainsKey("x");
Check.That(response.Message.Headers!["x"]).ContainsExactly(guid.ToString());
response.Message.Headers.Should().ContainKey("x");
response.Message.Headers!["x"].Should().ContainSingle(guid.ToString());
}
[Fact]
@@ -356,13 +346,13 @@ public class ResponseWithTransformerTests
var responseBuilder = Response.Create().WithHeader("x", "{{request.headers.Content-Type}}", "{{request.url}}").WithBody("test").WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
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");
response.Message.BodyData!.BodyAsString.Should().Be("test");
response.Message.Headers.Should().ContainKey("x");
response.Message.Headers!["x"].Should().Contain("text/plain");
response.Message.Headers["x"].Should().Contain("http://localhost/foo");
}
[Theory(Skip = "WireMockList is not supported by Scriban")]
@@ -381,13 +371,13 @@ public class ResponseWithTransformerTests
var responseBuilder = Response.Create().WithHeader("x", "{{request.Headers[\"Content-Type\"]}}", "{{request.Url}}").WithBody("test").WithTransformer(transformerType);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
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");
response.Message.BodyData!.BodyAsString.Should().Be("test");
response.Message.Headers.Should().ContainKey("x");
response.Message.Headers!["x"].Should().Contain("text/plain");
response.Message.Headers["x"].Should().Contain("http://localhost/foo");
}
[Theory]
@@ -409,10 +399,10 @@ public class ResponseWithTransformerTests
.WithTransformer(transformerType);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message.BodyData!.BodyAsString).Equals("test http://localhost:1234 1234 http localhost");
response.Message.BodyData!.BodyAsString.Should().Be("test http://localhost:1234 1234 http localhost");
}
[Theory]
@@ -436,13 +426,13 @@ public class ResponseWithTransformerTests
.WithTransformer(transformerType);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(JsonConvert.SerializeObject(response.Message.BodyData!.BodyAsJson)).Equals("{\"x\":\"test /foo_object\"}");
JsonConvert.SerializeObject(response.Message.BodyData!.BodyAsJson).Should().Be("{\"x\":\"test /foo_object\"}");
}
[CulturedTheory("en-US")]
[CulturedTheory(["en-US"])]
[InlineData(TransformerType.Handlebars, "{ \"id\": 42 }", "{\"x\":\"test 42\",\"y\":42}")]
[InlineData(TransformerType.Scriban, "{ \"id\": 42 }", "{\"x\":\"test 42\",\"y\":42}")]
[InlineData(TransformerType.ScribanDotLiquid, "{ \"id\": 42 }", "{\"x\":\"test 42\",\"y\":42}")]
@@ -478,7 +468,7 @@ public class ResponseWithTransformerTests
.WithTransformer(transformerType);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, settings);
// Assert
JsonConvert.SerializeObject(response.Message.BodyData!.BodyAsJson).Should().Be(expected);
@@ -498,7 +488,7 @@ public class ResponseWithTransformerTests
.WithTransformer(transformerType);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
JsonConvert.SerializeObject(response.Message.BodyData!.BodyAsJson).Should().Be("[{\"x\":\"test\"}]");
@@ -519,7 +509,7 @@ public class ResponseWithTransformerTests
.WithTransformer(transformerType);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
JsonConvert.SerializeObject(response.Message.BodyData!.BodyAsJson).Should().Be("[{\"x\":\"test\"}]");
@@ -556,7 +546,7 @@ public class ResponseWithTransformerTests
.WithTransformer(transformerType, false, ReplaceNodeOptions.Evaluate);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
JsonConvert.SerializeObject(response.Message.BodyData!.BodyAsJson).Should().Be($"{{\"text\":{expected}}}");
@@ -583,10 +573,10 @@ public class ResponseWithTransformerTests
.WithTransformer(transformerType);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(JsonConvert.SerializeObject(response.Message.BodyData!.BodyAsJson)).Equals("[\"first\",\"/foo_array\",\"test 1\",\"test 2\",\"last\"]");
JsonConvert.SerializeObject(response.Message.BodyData!.BodyAsJson).Should().Be("[\"first\",\"/foo_array\",\"test 1\",\"test 2\",\"last\"]");
}
[Fact]
@@ -600,10 +590,10 @@ public class ResponseWithTransformerTests
.WithBodyFromFile(@"c:\\{{request.query.MyUniqueNumber}}\\test.xml");
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message.BodyData!.BodyAsFile).Equals(@"c:\1\test.xml");
response.Message.BodyData!.BodyAsFile.Should().Be(@"c:\1\test.xml");
}
[Theory(Skip = @"Does not work in Scriban --> c:\\[""1""]\\test.xml")]
@@ -619,10 +609,10 @@ public class ResponseWithTransformerTests
.WithBodyFromFile(@"c:\\{{request.query.MyUniqueNumber}}\\test.xml");
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(response.Message.BodyData!.BodyAsFile).Equals(@"c:\1\test.xml");
response.Message.BodyData!.BodyAsFile.Should().Be(@"c:\1\test.xml");
}
[Fact]
@@ -643,12 +633,12 @@ public class ResponseWithTransformerTests
.WithBodyFromFile(@"c:\\{{request.query.MyUniqueNumber}}\\test.xml");
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
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>");
response.Message.BodyData!.BodyAsFile.Should().Be(@"c:\1\test.xml");
response.Message.BodyData.DetectedBodyType.Should().Be(BodyType.String);
response.Message.BodyData!.BodyAsString.Should().Be("<xml MyUniqueNumber=\"1\"></xml>");
}
[Theory]
@@ -672,10 +662,10 @@ public class ResponseWithTransformerTests
.WithTransformer(transformerType);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(JsonConvert.SerializeObject(response.Message.BodyData!.BodyAsJson)).Equals("\"test\"");
JsonConvert.SerializeObject(response.Message.BodyData!.BodyAsJson).Should().Be("\"test\"");
}
[Fact]
@@ -693,7 +683,7 @@ public class ResponseWithTransformerTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
JsonConvert.SerializeObject(response.Message.BodyData!.BodyAsJson).Should().Be("{\"scope\":\"scope1 scope2 scope3 helloworld\"}");
@@ -718,10 +708,10 @@ public class ResponseWithTransformerTests
.WithTransformer();
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(JsonConvert.SerializeObject(response.Message.BodyData!.BodyAsJson)).Equals("{\"name\":\"WireMock\"}");
JsonConvert.SerializeObject(response.Message.BodyData!.BodyAsJson).Should().Be("{\"name\":\"WireMock\"}");
}
[Theory(Skip = "{{{ }}} Does not work in Scriban")]
@@ -744,10 +734,10 @@ public class ResponseWithTransformerTests
.WithTransformer(transformerType);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
Check.That(JsonConvert.SerializeObject(response.Message.BodyData!.BodyAsJson)).Equals("{\"name\":\"WireMock\"}");
JsonConvert.SerializeObject(response.Message.BodyData!.BodyAsJson).Should().Be("{\"name\":\"WireMock\"}");
}
[Theory]
@@ -772,14 +762,13 @@ public class ResponseWithTransformerTests
.WithTransformer(transformerType);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
response.Message.BodyData!.BodyAsString.Should().Be(text);
response.Message.BodyData.Encoding.Should().Be(enc);
}
#if MIMEKIT
[Theory]
[InlineData(TransformerType.Handlebars)]
// [InlineData(TransformerType.Scriban)]
@@ -825,12 +814,11 @@ AAAADElEQVR4XmMQYNgAAADkAMHebX3mAAAAAElFTkSuQmCC
.WithTransformer(transformerType);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
response.Message.BodyData!.BodyAsString.Should().Be("text/plain text/json image.png");
}
#endif
[Theory]
[InlineData("/wiremock-data/1", "one")]
@@ -853,9 +841,12 @@ AAAADElEQVR4XmMQYNgAAADkAMHebX3mAAAAAElFTkSuQmCC
_mappingMock.SetupGet(m => m.Data).Returns(data);
// Act
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, Mock.Of<HttpContext>(), request, _settings);
// Assert
response.Message.BodyData!.BodyAsString.Should().Be(expected);
}
}
}