starred/WireMock.Net
1
0
Fork 0
mirror of https://github.com/wiremock/WireMock.Net.git synced 2026-04-19 15:31:39 +02: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

12
WireMock.Net Solution.sln
View File

@@ -82,8 +82,6 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WireMock.Net.Matchers.CShar
EndProject EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WireMock.Net.Console.Net472.Classic", "examples\WireMock.Net.Console.Net472.Classic\WireMock.Net.Console.Net472.Classic.csproj", "{6580580B-1EFD-4922-B0EC-FF290DB279EE}" Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WireMock.Net.Console.Net472.Classic", "examples\WireMock.Net.Console.Net472.Classic\WireMock.Net.Console.Net472.Classic.csproj", "{6580580B-1EFD-4922-B0EC-FF290DB279EE}"
EndProject EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WireMock.Net.XamarinUI.Tests", "test\WireMock.Net.XamarinUI.Tests\WireMock.Net.XamarinUI.Tests.csproj", "{0DE14F1B-A51E-4B59-A87C-C6012DCD2844}"
EndProject
Global Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU Debug|Any CPU = Debug|Any CPU
@@ -206,14 +204,6 @@ Global
{6580580B-1EFD-4922-B0EC-FF290DB279EE}.Debug|Any CPU.Build.0 = Debug|Any CPU {6580580B-1EFD-4922-B0EC-FF290DB279EE}.Debug|Any CPU.Build.0 = Debug|Any CPU
{6580580B-1EFD-4922-B0EC-FF290DB279EE}.Release|Any CPU.ActiveCfg = Release|Any CPU {6580580B-1EFD-4922-B0EC-FF290DB279EE}.Release|Any CPU.ActiveCfg = Release|Any CPU
{6580580B-1EFD-4922-B0EC-FF290DB279EE}.Release|Any CPU.Build.0 = Release|Any CPU {6580580B-1EFD-4922-B0EC-FF290DB279EE}.Release|Any CPU.Build.0 = Release|Any CPU
{0DE14F1B-A51E-4B59-A87C-C6012DCD2844}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{0DE14F1B-A51E-4B59-A87C-C6012DCD2844}.Debug|Any CPU.Build.0 = Debug|Any CPU
{0DE14F1B-A51E-4B59-A87C-C6012DCD2844}.Release|Any CPU.ActiveCfg = Release|Any CPU
{0DE14F1B-A51E-4B59-A87C-C6012DCD2844}.Release|Any CPU.Build.0 = Release|Any CPU
{B6269AAC-170A-4346-8B9A-444DED3D9A44}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{B6269AAC-170A-4346-8B9A-444DED3D9A44}.Debug|Any CPU.Build.0 = Debug|Any CPU
{B6269AAC-170A-4346-8B9A-444DED3D9A44}.Release|Any CPU.ActiveCfg = Release|Any CPU
{B6269AAC-170A-4346-8B9A-444DED3D9A44}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection EndGlobalSection
GlobalSection(SolutionProperties) = preSolution GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE HideSolutionNode = FALSE
@@ -247,9 +237,7 @@ Global
{40BF24B5-12E6-4610-9489-138798632E28} = {8F890C6F-9ACC-438D-928A-AD61CDA862F2} {40BF24B5-12E6-4610-9489-138798632E28} = {8F890C6F-9ACC-438D-928A-AD61CDA862F2}
{3F8CF0AE-5F24-4A54-89E7-A3EE829DB5F8} = {985E0ADB-D4B4-473A-AA40-567E279B7946} {3F8CF0AE-5F24-4A54-89E7-A3EE829DB5F8} = {985E0ADB-D4B4-473A-AA40-567E279B7946}
{B6269AAC-170A-4346-8B9A-444DED3D9A44} = {8F890C6F-9ACC-438D-928A-AD61CDA862F2} {B6269AAC-170A-4346-8B9A-444DED3D9A44} = {8F890C6F-9ACC-438D-928A-AD61CDA862F2}
{B6269AAC-170A-4346-8B9A-444DED3D9A44} = {8F890C6F-9ACC-438D-928A-AD61CDA862F2}
{6580580B-1EFD-4922-B0EC-FF290DB279EE} = {985E0ADB-D4B4-473A-AA40-567E279B7946} {6580580B-1EFD-4922-B0EC-FF290DB279EE} = {985E0ADB-D4B4-473A-AA40-567E279B7946}
{0DE14F1B-A51E-4B59-A87C-C6012DCD2844} = {0BB8B634-407A-4610-A91F-11586990767A}
EndGlobalSection EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {DC539027-9852-430C-B19F-FD035D018458} SolutionGuid = {DC539027-9852-430C-B19F-FD035D018458}

8
examples/WireMock.Net.Service/WireMock.Net.Service.csproj
View File

@@ -32,11 +32,8 @@
<WarningLevel>4</WarningLevel> <WarningLevel>4</WarningLevel>
</PropertyGroup> </PropertyGroup>
<ItemGroup> <ItemGroup>
<Reference Include="Handlebars, Version=1.9.5.0, Culture=neutral, PublicKeyToken=22225d0bf33cd661, processorArchitecture=MSIL"> <Reference Include="log4net, Version=2.0.12.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a, processorArchitecture=MSIL">
<HintPath>..\..\packages\Handlebars.Net.1.9.5\lib\net452\Handlebars.dll</HintPath> <HintPath>..\..\packages\log4net.2.0.12\lib\net45\log4net.dll</HintPath>
</Reference>
<Reference Include="log4net, Version=2.0.8.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a, processorArchitecture=MSIL">
<HintPath>..\..\packages\log4net.2.0.8\lib\net45-full\log4net.dll</HintPath>
</Reference> </Reference>
<Reference Include="Microsoft.Owin, Version=2.0.2.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL"> <Reference Include="Microsoft.Owin, Version=2.0.2.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
<HintPath>..\..\packages\Microsoft.Owin.2.0.2\lib\net45\Microsoft.Owin.dll</HintPath> <HintPath>..\..\packages\Microsoft.Owin.2.0.2\lib\net45\Microsoft.Owin.dll</HintPath>
@@ -57,6 +54,7 @@
<HintPath>..\..\packages\SimMetrics.Net.1.0.5\lib\net45\SimMetrics.Net.dll</HintPath> <HintPath>..\..\packages\SimMetrics.Net.1.0.5\lib\net45\SimMetrics.Net.dll</HintPath>
</Reference> </Reference>
<Reference Include="System" /> <Reference Include="System" />
<Reference Include="System.Configuration" />
<Reference Include="System.Configuration.Install" /> <Reference Include="System.Configuration.Install" />
<Reference Include="System.Core" /> <Reference Include="System.Core" />
<Reference Include="System.Management" /> <Reference Include="System.Management" />

3
examples/WireMock.Net.Service/packages.config
View File

@@ -1,7 +1,6 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<packages> <packages>
<package id="Handlebars.Net" version="1.9.5" targetFramework="net452" /> <package id="log4net" version="2.0.12" targetFramework="net452" />
<package id="log4net" version="2.0.10" targetFramework="net452" />
<package id="Microsoft.AspNet.WebApi.Client" version="5.2.3" targetFramework="net452" /> <package id="Microsoft.AspNet.WebApi.Client" version="5.2.3" targetFramework="net452" />
<package id="Microsoft.AspNet.WebApi.Core" version="5.2.3" targetFramework="net452" /> <package id="Microsoft.AspNet.WebApi.Core" version="5.2.3" targetFramework="net452" />
<package id="Microsoft.AspNet.WebApi.Owin" version="5.2.3" targetFramework="net452" /> <package id="Microsoft.AspNet.WebApi.Owin" version="5.2.3" targetFramework="net452" />

6
examples/WireMock.Net.StandAlone.Net452/WireMock.Net.StandAlone.Net452.csproj
View File

@@ -39,8 +39,8 @@
<StartupObject>WireMock.Net.StandAlone.Net452.Program</StartupObject> <StartupObject>WireMock.Net.StandAlone.Net452.Program</StartupObject>
</PropertyGroup> </PropertyGroup>
<ItemGroup> <ItemGroup>
<Reference Include="log4net, Version=2.0.8.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a, processorArchitecture=MSIL"> <Reference Include="log4net, Version=2.0.12.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a, processorArchitecture=MSIL">
<HintPath>..\..\packages\log4net.2.0.8\lib\net45-full\log4net.dll</HintPath> <HintPath>..\..\packages\log4net.2.0.12\lib\net45\log4net.dll</HintPath>
</Reference> </Reference>
<Reference Include="Microsoft.Owin.Host.HttpListener, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL"> <Reference Include="Microsoft.Owin.Host.HttpListener, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
<HintPath>..\..\packages\Microsoft.Owin.Host.HttpListener.4.0.0\lib\net451\Microsoft.Owin.Host.HttpListener.dll</HintPath> <HintPath>..\..\packages\Microsoft.Owin.Host.HttpListener.4.0.0\lib\net451\Microsoft.Owin.Host.HttpListener.dll</HintPath>
@@ -49,12 +49,14 @@
<HintPath>..\..\packages\Newtonsoft.Json.11.0.2\lib\net45\Newtonsoft.Json.dll</HintPath> <HintPath>..\..\packages\Newtonsoft.Json.11.0.2\lib\net45\Newtonsoft.Json.dll</HintPath>
</Reference> </Reference>
<Reference Include="System" /> <Reference Include="System" />
<Reference Include="System.Configuration" />
<Reference Include="System.Core" /> <Reference Include="System.Core" />
<Reference Include="System.Net.Http" /> <Reference Include="System.Net.Http" />
<Reference Include="System.Net.Http.Formatting, Version=5.2.6.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL"> <Reference Include="System.Net.Http.Formatting, Version=5.2.6.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
<HintPath>..\..\packages\Microsoft.AspNet.WebApi.Client.5.2.6\lib\net45\System.Net.Http.Formatting.dll</HintPath> <HintPath>..\..\packages\Microsoft.AspNet.WebApi.Client.5.2.6\lib\net45\System.Net.Http.Formatting.dll</HintPath>
</Reference> </Reference>
<Reference Include="System.Numerics" /> <Reference Include="System.Numerics" />
<Reference Include="System.Web" />
<Reference Include="System.Xml" /> <Reference Include="System.Xml" />
<Reference Include="System.Xml.Linq" /> <Reference Include="System.Xml.Linq" />
</ItemGroup> </ItemGroup>

2
examples/WireMock.Net.StandAlone.Net452/packages.config
View File

@@ -1,6 +1,6 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<packages> <packages>
<package id="log4net" version="2.0.10" targetFramework="net452" /> <package id="log4net" version="2.0.12" targetFramework="net452" />
<package id="Microsoft.AspNet.WebApi.Client" version="5.2.6" targetFramework="net452" /> <package id="Microsoft.AspNet.WebApi.Client" version="5.2.6" targetFramework="net452" />
<package id="Microsoft.Owin.Host.HttpListener" version="4.0.0" targetFramework="net452" /> <package id="Microsoft.Owin.Host.HttpListener" version="4.0.0" targetFramework="net452" />
<package id="Newtonsoft.Json" version="11.0.2" targetFramework="net452" /> <package id="Newtonsoft.Json" version="11.0.2" targetFramework="net452" />

4
src/WireMock.Net/IMapping.cs
View File

@@ -103,8 +103,8 @@ namespace WireMock
/// ProvideResponseAsync /// ProvideResponseAsync
/// </summary> /// </summary>
/// <param name="requestMessage">The request message.</param> /// <param name="requestMessage">The request message.</param>
/// <returns>The <see cref="ResponseMessage"/>.</returns> /// <returns>The <see cref="ResponseMessage"/> including a new (optional) <see cref="IMapping"/>.</returns>
Task<ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage); Task<(ResponseMessage Message, IMapping Mapping)> ProvideResponseAsync(RequestMessage requestMessage);
/// <summary> /// <summary>
/// Gets the RequestMatchResult based on the RequestMessage. /// Gets the RequestMatchResult based on the RequestMessage.

2
src/WireMock.Net/Mapping.cs
View File

@@ -103,7 +103,7 @@ namespace WireMock
} }
/// <inheritdoc cref="IMapping.ProvideResponseAsync" /> /// <inheritdoc cref="IMapping.ProvideResponseAsync" />
public async Task<ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage) public async Task<(ResponseMessage Message, IMapping Mapping)> ProvideResponseAsync(RequestMessage requestMessage)
{ {
return await Provider.ProvideResponseAsync(requestMessage, Settings); return await Provider.ProvideResponseAsync(requestMessage, Settings);
} }

2
src/WireMock.Net/Models/BodyData.cs
View File

@@ -6,7 +6,7 @@ namespace WireMock.Util
/// <summary> /// <summary>
/// BodyData /// BodyData
/// </summary> /// </summary>
internal class BodyData : IBodyData public class BodyData : IBodyData
{ {
/// <inheritdoc cref="IBodyData.Encoding" /> /// <inheritdoc cref="IBodyData.Encoding" />
public Encoding Encoding { get; set; } public Encoding Encoding { get; set; }

9
src/WireMock.Net/Owin/WireMockMiddleware.cs
View File

@@ -129,15 +129,16 @@ namespace WireMock.Owin
await Task.Delay(_options.RequestProcessingDelay.Value); await Task.Delay(_options.RequestProcessingDelay.Value);
} }
response = await targetMapping.ProvideResponseAsync(request); var (theResponse, theOptionalNewMapping) = await targetMapping.ProvideResponseAsync(request);
response = theResponse;
var responseBuilder = targetMapping.Provider as Response; var responseBuilder = targetMapping.Provider as Response;
if (!targetMapping.IsAdminInterface) if (!targetMapping.IsAdminInterface && theOptionalNewMapping != null)
{ {
if (responseBuilder?.ProxyAndRecordSettings?.SaveMapping == true || targetMapping?.Settings?.ProxyAndRecordSettings?.SaveMapping == true) if (responseBuilder?.ProxyAndRecordSettings?.SaveMapping == true || targetMapping?.Settings?.ProxyAndRecordSettings?.SaveMapping == true)
{ {
_options.Mappings.TryAdd(targetMapping.Guid, targetMapping); _options.Mappings.TryAdd(theOptionalNewMapping.Guid, theOptionalNewMapping);
} }
if (responseBuilder?.ProxyAndRecordSettings?.SaveMappingToFile == true || targetMapping?.Settings?.ProxyAndRecordSettings?.SaveMappingToFile == true) if (responseBuilder?.ProxyAndRecordSettings?.SaveMappingToFile == true || targetMapping?.Settings?.ProxyAndRecordSettings?.SaveMappingToFile == true)
@@ -146,7 +147,7 @@ namespace WireMock.Owin
var mappingConverter = new MappingConverter(matcherMapper); var mappingConverter = new MappingConverter(matcherMapper);
var mappingToFileSaver = new MappingToFileSaver(targetMapping.Settings, mappingConverter); var mappingToFileSaver = new MappingToFileSaver(targetMapping.Settings, mappingConverter);
mappingToFileSaver.SaveMappingToFile(targetMapping); mappingToFileSaver.SaveMappingToFile(theOptionalNewMapping);
} }
} }

216
src/WireMock.Net/Proxy/ProxyHelper.cs
View File

@@ -1,111 +1,111 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Net.Http; using System.Net.Http;
using System.Threading.Tasks; using System.Threading.Tasks;
using JetBrains.Annotations; using JetBrains.Annotations;
using WireMock.Http; using WireMock.Http;
using WireMock.Matchers; using WireMock.Matchers;
using WireMock.RequestBuilders; using WireMock.RequestBuilders;
using WireMock.ResponseBuilders; using WireMock.ResponseBuilders;
using WireMock.Settings; using WireMock.Settings;
using WireMock.Types; using WireMock.Types;
using WireMock.Util; using WireMock.Util;
using WireMock.Validation; using WireMock.Validation;
namespace WireMock.Proxy namespace WireMock.Proxy
{ {
internal class ProxyHelper internal class ProxyHelper
{ {
private readonly IWireMockServerSettings _settings; private readonly IWireMockServerSettings _settings;
public ProxyHelper([NotNull] IWireMockServerSettings settings) public ProxyHelper([NotNull] IWireMockServerSettings settings)
{ {
Check.NotNull(settings, nameof(settings)); Check.NotNull(settings, nameof(settings));
_settings = settings; _settings = settings;
} }
public async Task<(ResponseMessage ResponseMessage, IMapping Mapping)> SendAsync( public async Task<(ResponseMessage Message, IMapping Mapping)> SendAsync(
[NotNull] IProxyAndRecordSettings proxyAndRecordSettings, [NotNull] IProxyAndRecordSettings proxyAndRecordSettings,
[NotNull] HttpClient client, [NotNull] HttpClient client,
[NotNull] RequestMessage requestMessage, [NotNull] RequestMessage requestMessage,
[NotNull] string url) [NotNull] string url)
{ {
Check.NotNull(client, nameof(client)); Check.NotNull(client, nameof(client));
Check.NotNull(requestMessage, nameof(requestMessage)); Check.NotNull(requestMessage, nameof(requestMessage));
Check.NotNull(url, nameof(url)); Check.NotNull(url, nameof(url));
var originalUri = new Uri(requestMessage.Url); var originalUri = new Uri(requestMessage.Url);
var requiredUri = new Uri(url); var requiredUri = new Uri(url);
// Create HttpRequestMessage // Create HttpRequestMessage
var httpRequestMessage = HttpRequestMessageHelper.Create(requestMessage, url); var httpRequestMessage = HttpRequestMessageHelper.Create(requestMessage, url);
// Call the URL // Call the URL
var httpResponseMessage = await client.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseContentRead); var httpResponseMessage = await client.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseContentRead);
// Create ResponseMessage // Create ResponseMessage
bool deserializeJson = !_settings.DisableJsonBodyParsing.GetValueOrDefault(false); bool deserializeJson = !_settings.DisableJsonBodyParsing.GetValueOrDefault(false);
bool decompressGzipAndDeflate = !_settings.DisableRequestBodyDecompressing.GetValueOrDefault(false); bool decompressGzipAndDeflate = !_settings.DisableRequestBodyDecompressing.GetValueOrDefault(false);
var responseMessage = await HttpResponseMessageHelper.CreateAsync(httpResponseMessage, requiredUri, originalUri, deserializeJson, decompressGzipAndDeflate); var responseMessage = await HttpResponseMessageHelper.CreateAsync(httpResponseMessage, requiredUri, originalUri, deserializeJson, decompressGzipAndDeflate);
IMapping mapping = null; IMapping mapping = null;
if (HttpStatusRangeParser.IsMatch(proxyAndRecordSettings.SaveMappingForStatusCodePattern, responseMessage.StatusCode) && if (HttpStatusRangeParser.IsMatch(proxyAndRecordSettings.SaveMappingForStatusCodePattern, responseMessage.StatusCode) &&
(proxyAndRecordSettings.SaveMapping || proxyAndRecordSettings.SaveMappingToFile)) (proxyAndRecordSettings.SaveMapping || proxyAndRecordSettings.SaveMappingToFile))
{ {
mapping = ToMapping(proxyAndRecordSettings, requestMessage, responseMessage); mapping = ToMapping(proxyAndRecordSettings, requestMessage, responseMessage);
} }
return (responseMessage, mapping); return (responseMessage, mapping);
} }
private IMapping ToMapping(IProxyAndRecordSettings proxyAndRecordSettings, RequestMessage requestMessage, ResponseMessage responseMessage) private IMapping ToMapping(IProxyAndRecordSettings proxyAndRecordSettings, RequestMessage requestMessage, ResponseMessage responseMessage)
{ {
string[] excludedHeaders = proxyAndRecordSettings.ExcludedHeaders ?? new string[] { }; string[] excludedHeaders = proxyAndRecordSettings.ExcludedHeaders ?? new string[] { };
string[] excludedCookies = proxyAndRecordSettings.ExcludedCookies ?? new string[] { }; string[] excludedCookies = proxyAndRecordSettings.ExcludedCookies ?? new string[] { };
var request = Request.Create(); var request = Request.Create();
request.WithPath(requestMessage.Path); request.WithPath(requestMessage.Path);
request.UsingMethod(requestMessage.Method); request.UsingMethod(requestMessage.Method);
requestMessage.Query.Loop((key, value) => request.WithParam(key, false, value.ToArray())); requestMessage.Query.Loop((key, value) => request.WithParam(key, false, value.ToArray()));
requestMessage.Cookies.Loop((key, value) => requestMessage.Cookies.Loop((key, value) =>
{ {
if (!excludedCookies.Contains(key, StringComparer.OrdinalIgnoreCase)) if (!excludedCookies.Contains(key, StringComparer.OrdinalIgnoreCase))
{ {
request.WithCookie(key, value); request.WithCookie(key, value);
} }
}); });
var allExcludedHeaders = new List<string>(excludedHeaders) { "Cookie" }; var allExcludedHeaders = new List<string>(excludedHeaders) { "Cookie" };
requestMessage.Headers.Loop((key, value) => requestMessage.Headers.Loop((key, value) =>
{ {
if (!allExcludedHeaders.Contains(key, StringComparer.OrdinalIgnoreCase)) if (!allExcludedHeaders.Contains(key, StringComparer.OrdinalIgnoreCase))
{ {
request.WithHeader(key, value.ToArray()); request.WithHeader(key, value.ToArray());
} }
}); });
bool throwExceptionWhenMatcherFails = _settings.ThrowExceptionWhenMatcherFails == true; bool throwExceptionWhenMatcherFails = _settings.ThrowExceptionWhenMatcherFails == true;
switch (requestMessage.BodyData?.DetectedBodyType) switch (requestMessage.BodyData?.DetectedBodyType)
{ {
case BodyType.Json: case BodyType.Json:
request.WithBody(new JsonMatcher(MatchBehaviour.AcceptOnMatch, requestMessage.BodyData.BodyAsJson, true, throwExceptionWhenMatcherFails)); request.WithBody(new JsonMatcher(MatchBehaviour.AcceptOnMatch, requestMessage.BodyData.BodyAsJson, true, throwExceptionWhenMatcherFails));
break; break;
case BodyType.String: case BodyType.String:
request.WithBody(new ExactMatcher(MatchBehaviour.AcceptOnMatch, throwExceptionWhenMatcherFails, requestMessage.BodyData.BodyAsString)); request.WithBody(new ExactMatcher(MatchBehaviour.AcceptOnMatch, throwExceptionWhenMatcherFails, requestMessage.BodyData.BodyAsString));
break; break;
case BodyType.Bytes: case BodyType.Bytes:
request.WithBody(new ExactObjectMatcher(MatchBehaviour.AcceptOnMatch, requestMessage.BodyData.BodyAsBytes, throwExceptionWhenMatcherFails)); request.WithBody(new ExactObjectMatcher(MatchBehaviour.AcceptOnMatch, requestMessage.BodyData.BodyAsBytes, throwExceptionWhenMatcherFails));
break; break;
} }
var response = Response.Create(responseMessage); var response = Response.Create(responseMessage);
return new Mapping(Guid.NewGuid(), string.Empty, null, _settings, request, response, 0, null, null, null, null, null); return new Mapping(Guid.NewGuid(), string.Empty, null, _settings, request, response, 0, null, null, null, null, null);
} }
} }
} }

10
src/WireMock.Net/ResponseBuilders/Response.cs
View File

@@ -335,7 +335,7 @@ namespace WireMock.ResponseBuilders
} }
/// <inheritdoc cref="IResponseProvider.ProvideResponseAsync(RequestMessage, IWireMockServerSettings)"/> /// <inheritdoc cref="IResponseProvider.ProvideResponseAsync(RequestMessage, IWireMockServerSettings)"/>
public async Task<ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IWireMockServerSettings settings) public async Task<(ResponseMessage Message, IMapping Mapping)> ProvideResponseAsync(RequestMessage requestMessage, IWireMockServerSettings settings)
{ {
Check.NotNull(requestMessage, nameof(requestMessage)); Check.NotNull(requestMessage, nameof(requestMessage));
Check.NotNull(settings, nameof(settings)); Check.NotNull(settings, nameof(settings));
@@ -361,14 +361,12 @@ namespace WireMock.ResponseBuilders
var proxyHelper = new ProxyHelper(settings); var proxyHelper = new ProxyHelper(settings);
var (proxyResponseMessage, _) = await proxyHelper.SendAsync( return await proxyHelper.SendAsync(
ProxyAndRecordSettings, ProxyAndRecordSettings,
_httpClientForProxy, _httpClientForProxy,
requestMessage, requestMessage,
requestMessage.ProxyUrl requestMessage.ProxyUrl
); );
return proxyResponseMessage;
} }
ResponseMessage responseMessage; ResponseMessage responseMessage;
@@ -420,7 +418,7 @@ namespace WireMock.ResponseBuilders
throw new NotImplementedException($"TransformerType '{TransformerType}' is not supported."); throw new NotImplementedException($"TransformerType '{TransformerType}' is not supported.");
} }
return responseMessageTransformer.Transform(requestMessage, responseMessage, UseTransformerForBodyAsFile); return (responseMessageTransformer.Transform(requestMessage, responseMessage, UseTransformerForBodyAsFile), null);
} }
if (!UseTransformer && ResponseMessage.BodyData?.BodyAsFileIsCached == true) if (!UseTransformer && ResponseMessage.BodyData?.BodyAsFileIsCached == true)
@@ -428,7 +426,7 @@ namespace WireMock.ResponseBuilders
ResponseMessage.BodyData.BodyAsBytes = settings.FileSystemHandler.ReadResponseBodyAsFile(responseMessage.BodyData.BodyAsFile); ResponseMessage.BodyData.BodyAsBytes = settings.FileSystemHandler.ReadResponseBodyAsFile(responseMessage.BodyData.BodyAsFile);
} }
return responseMessage; return (responseMessage, null);
} }
} }
} }

4
src/WireMock.Net/ResponseProviders/DynamicAsyncResponseProvider.cs
View File

@@ -13,9 +13,9 @@ namespace WireMock.ResponseProviders
_responseMessageFunc = responseMessageFunc; _responseMessageFunc = responseMessageFunc;
} }
public Task<ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IWireMockServerSettings settings) public async Task<(ResponseMessage Message, IMapping Mapping)> ProvideResponseAsync(RequestMessage requestMessage, IWireMockServerSettings settings)
{ {
return _responseMessageFunc(requestMessage); return (await _responseMessageFunc(requestMessage), null);
} }
} }
} }

5
src/WireMock.Net/ResponseProviders/DynamicResponseProvider.cs
View File

@@ -13,9 +13,10 @@ namespace WireMock.ResponseProviders
_responseMessageFunc = responseMessageFunc; _responseMessageFunc = responseMessageFunc;
} }
public Task<ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IWireMockServerSettings settings) public Task<(ResponseMessage Message, IMapping Mapping)> ProvideResponseAsync(RequestMessage requestMessage, IWireMockServerSettings settings)
{ {
return Task.FromResult(_responseMessageFunc(requestMessage)); (ResponseMessage responseMessage, IMapping mapping) result = (_responseMessageFunc(requestMessage), null);
return Task.FromResult(result);
} }
} }
} }

4
src/WireMock.Net/ResponseProviders/IResponseProvider.cs
View File

@@ -16,7 +16,7 @@ namespace WireMock.ResponseProviders
/// </summary> /// </summary>
/// <param name="requestMessage">The request.</param> /// <param name="requestMessage">The request.</param>
/// <param name="settings">The WireMockServerSettings.</param> /// <param name="settings">The WireMockServerSettings.</param>
/// <returns>The <see cref="ResponseMessage"/>.</returns> /// <returns>The <see cref="ResponseMessage"/> including a new (optional) <see cref="IMapping"/>.</returns>
Task<ResponseMessage> ProvideResponseAsync([NotNull] RequestMessage requestMessage, [NotNull] IWireMockServerSettings settings); Task<(ResponseMessage Message, IMapping Mapping)> ProvideResponseAsync([NotNull] RequestMessage requestMessage, [NotNull] IWireMockServerSettings settings);
} }
} }

4
src/WireMock.Net/ResponseProviders/ProxyAsyncResponseProvider.cs
View File

@@ -15,9 +15,9 @@ namespace WireMock.ResponseProviders
_settings = settings; _settings = settings;
} }
public Task<ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IWireMockServerSettings settings) public async Task<(ResponseMessage Message, IMapping Mapping)> ProvideResponseAsync(RequestMessage requestMessage, IWireMockServerSettings settings)
{ {
return _responseMessageFunc(requestMessage, _settings); return (await _responseMessageFunc(requestMessage, _settings), null);
} }
} }
} }

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

@@ -13,7 +13,6 @@ using WireMock.Matchers;
using System.Collections.Generic; using System.Collections.Generic;
using WireMock.Admin.Mappings; using WireMock.Admin.Mappings;
using WireMock.Admin.Requests; using WireMock.Admin.Requests;
using WireMock.ResponseProviders;
using WireMock.Settings; using WireMock.Settings;
using FluentAssertions; using FluentAssertions;
using WireMock.Handlers; using WireMock.Handlers;
@@ -177,7 +176,8 @@ namespace WireMock.Net.Tests.Owin
_mappingMock.SetupGet(m => m.Provider).Returns(responseBuilder); _mappingMock.SetupGet(m => m.Provider).Returns(responseBuilder);
_mappingMock.SetupGet(m => m.Settings).Returns(settings); _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(); var requestBuilder = Request.Create().UsingAnyMethod();
_mappingMock.SetupGet(m => m.RequestMatcher).Returns(requestBuilder); _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.Provider).Returns(responseBuilder);
_mappingMock.SetupGet(m => m.Settings).Returns(settings); _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(); var requestBuilder = Request.Create().UsingAnyMethod();
_mappingMock.SetupGet(m => m.RequestMatcher).Returns(requestBuilder); _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 responseMessage = new ResponseMessage { StatusCode = 500 };
var request = new RequestMessage(new UrlDetails("http://localhost"), "GET", "::1"); var request = new RequestMessage(new UrlDetails("http://localhost"), "GET", "::1");
var response = Response.Create(() => responseMessage); var responseBuilder = Response.Create(() => responseMessage);
// Act // Act
var providedResponse = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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 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 // act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// then // then
Check.That(responseMessage.BodyData.BodyAsString).Equals("01"); Check.That(response.Message.BodyData.BodyAsString).Equals("01");
Check.That(responseMessage.BodyData.BodyAsBytes).IsNull(); Check.That(response.Message.BodyData.BodyAsBytes).IsNull();
Check.That(responseMessage.BodyData.Encoding).Equals(Encoding.ASCII); Check.That(response.Message.BodyData.Encoding).Equals(Encoding.ASCII);
} }
[Fact] [Fact]
@@ -62,15 +62,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
}; };
var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, body); 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 // act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// then // then
Check.That(responseMessage.BodyData.BodyAsBytes).ContainsExactly(new byte[] { 48, 49 }); Check.That(response.Message.BodyData.BodyAsBytes).ContainsExactly(new byte[] { 48, 49 });
Check.That(responseMessage.BodyData.BodyAsString).IsNull(); Check.That(response.Message.BodyData.BodyAsString).IsNull();
Check.That(responseMessage.BodyData.Encoding).IsNull(); Check.That(response.Message.BodyData.Encoding).IsNull();
} }
[Fact] [Fact]
@@ -84,14 +84,14 @@ namespace WireMock.Net.Tests.ResponseBuilders
}; };
var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, body); 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 // act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// then // then
Check.That(responseMessage.BodyData.BodyAsString).Equals("test"); Check.That(response.Message.BodyData.BodyAsString).Equals("test");
Check.That(responseMessage.BodyData.Encoding).Equals(Encoding.ASCII); Check.That(response.Message.BodyData.Encoding).Equals(Encoding.ASCII);
} }
[Fact] [Fact]
@@ -106,14 +106,14 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, body); var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, body);
object x = new { value = "test" }; object x = new { value = "test" };
var response = Response.Create().WithBodyAsJson(x, Encoding.ASCII); var responseBuilder = Response.Create().WithBodyAsJson(x, Encoding.ASCII);
// act // act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// then // then
Check.That(responseMessage.BodyData.BodyAsJson).Equals(x); Check.That(response.Message.BodyData.BodyAsJson).Equals(x);
Check.That(responseMessage.BodyData.Encoding).Equals(Encoding.ASCII); Check.That(response.Message.BodyData.Encoding).Equals(Encoding.ASCII);
} }
[Fact] [Fact]
@@ -128,14 +128,14 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, body); var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, body);
object x = new { message = "Hello" }; object x = new { message = "Hello" };
var response = Response.Create().WithBodyAsJson(x, true); var responseBuilder = Response.Create().WithBodyAsJson(x, true);
// act // act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// then // then
Check.That(responseMessage.BodyData.BodyAsJson).Equals(x); Check.That(response.Message.BodyData.BodyAsJson).Equals(x);
Check.That(responseMessage.BodyData.BodyAsJsonIndented).IsEqualTo(true); Check.That(response.Message.BodyData.BodyAsJsonIndented).IsEqualTo(true);
} }
[Fact] [Fact]
@@ -144,16 +144,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign // Assign
var request = new RequestMessage(new UrlDetails("http://localhost"), "GET", ClientIp); 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 // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(responseMessage.BodyData.BodyAsBytes).IsNull(); Check.That(response.Message.BodyData.BodyAsBytes).IsNull();
Check.That(responseMessage.BodyData.BodyAsJson).IsNull(); Check.That(response.Message.BodyData.BodyAsJson).IsNull();
Check.That(responseMessage.BodyData.BodyAsString).Equals("r"); Check.That(response.Message.BodyData.BodyAsString).Equals("r");
Check.That(responseMessage.BodyData.Encoding).Equals(Encoding.ASCII); Check.That(response.Message.BodyData.Encoding).Equals(Encoding.ASCII);
} }
[Fact] [Fact]
@@ -162,16 +162,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign // Assign
var request = new RequestMessage(new UrlDetails("http://localhost"), "GET", ClientIp); 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 // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(responseMessage.BodyData.BodyAsString).IsNull(); Check.That(response.Message.BodyData.BodyAsString).IsNull();
Check.That(responseMessage.BodyData.BodyAsJson).IsNull(); Check.That(response.Message.BodyData.BodyAsJson).IsNull();
Check.That(responseMessage.BodyData.BodyAsBytes).IsNotNull(); Check.That(response.Message.BodyData.BodyAsBytes).IsNotNull();
Check.That(responseMessage.BodyData.Encoding).Equals(Encoding.ASCII); Check.That(response.Message.BodyData.Encoding).Equals(Encoding.ASCII);
} }
[Fact] [Fact]
@@ -180,16 +180,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign // Assign
var request = new RequestMessage(new UrlDetails("http://localhost"), "GET", ClientIp); 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 // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(responseMessage.BodyData.BodyAsString).IsNull(); Check.That(response.Message.BodyData.BodyAsString).IsNull();
Check.That(responseMessage.BodyData.BodyAsBytes).IsNull(); Check.That(response.Message.BodyData.BodyAsBytes).IsNull();
Check.That(((dynamic)responseMessage.BodyData.BodyAsJson).value).Equals(42); Check.That(((dynamic)response.Message.BodyData.BodyAsJson).value).Equals(42);
Check.That(responseMessage.BodyData.Encoding).Equals(Encoding.ASCII); Check.That(response.Message.BodyData.Encoding).Equals(Encoding.ASCII);
} }
[Fact] [Fact]
@@ -198,23 +198,23 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign // Assign
var request = new RequestMessage(new UrlDetails("http://localhost/test"), "GET", ClientIp); var request = new RequestMessage(new UrlDetails("http://localhost/test"), "GET", ClientIp);
var response = Response.Create() var responseBuilder = Response.Create()
.WithStatusCode(500) .WithStatusCode(500)
.WithHeader("H1", "X1") .WithHeader("H1", "X1")
.WithHeader("H2", "X2") .WithHeader("H2", "X2")
.WithBody(req => $"path: {req.Path}"); .WithBody(req => $"path: {req.Path}");
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(responseMessage.BodyData.BodyAsString).IsEqualTo("path: /test"); Check.That(response.Message.BodyData.BodyAsString).IsEqualTo("path: /test");
Check.That(responseMessage.BodyData.BodyAsBytes).IsNull(); Check.That(response.Message.BodyData.BodyAsBytes).IsNull();
Check.That(responseMessage.BodyData.BodyAsJson).IsNull(); Check.That(response.Message.BodyData.BodyAsJson).IsNull();
Check.That(responseMessage.BodyData.Encoding.CodePage).Equals(Encoding.UTF8.CodePage); Check.That(response.Message.BodyData.Encoding.CodePage).Equals(Encoding.UTF8.CodePage);
Check.That(responseMessage.StatusCode).IsEqualTo(500); Check.That(response.Message.StatusCode).IsEqualTo(500);
Check.That(responseMessage.Headers["H1"].ToString()).IsEqualTo("X1"); Check.That(response.Message.Headers["H1"].ToString()).IsEqualTo("X1");
Check.That(responseMessage.Headers["H2"].ToString()).IsEqualTo("X2"); Check.That(response.Message.Headers["H2"].ToString()).IsEqualTo("X2");
} }
[Fact] [Fact]
@@ -223,7 +223,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign // Assign
var request = new RequestMessage(new UrlDetails("http://localhost/test"), "GET", ClientIp); var request = new RequestMessage(new UrlDetails("http://localhost/test"), "GET", ClientIp);
var response = Response.Create() var responseBuilder = Response.Create()
.WithStatusCode(500) .WithStatusCode(500)
.WithHeader("H1", "X1") .WithHeader("H1", "X1")
.WithHeader("H2", "X2") .WithHeader("H2", "X2")
@@ -234,16 +234,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
}); });
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(responseMessage.BodyData.BodyAsString).IsEqualTo("path: /test"); Check.That(response.Message.BodyData.BodyAsString).IsEqualTo("path: /test");
Check.That(responseMessage.BodyData.BodyAsBytes).IsNull(); Check.That(response.Message.BodyData.BodyAsBytes).IsNull();
Check.That(responseMessage.BodyData.BodyAsJson).IsNull(); Check.That(response.Message.BodyData.BodyAsJson).IsNull();
Check.That(responseMessage.BodyData.Encoding.CodePage).Equals(Encoding.UTF8.CodePage); Check.That(response.Message.BodyData.Encoding.CodePage).Equals(Encoding.UTF8.CodePage);
Check.That(responseMessage.StatusCode).IsEqualTo(500); Check.That(response.Message.StatusCode).IsEqualTo(500);
Check.That(responseMessage.Headers["H1"].ToString()).IsEqualTo("X1"); Check.That(response.Message.Headers["H1"].ToString()).IsEqualTo("X1");
Check.That(responseMessage.Headers["H2"].ToString()).IsEqualTo("X2"); Check.That(response.Message.Headers["H2"].ToString()).IsEqualTo("X2");
} }
[Fact] [Fact]
@@ -256,25 +256,25 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request1 = new RequestMessage(new UrlDetails($"http://localhost/test?id={request1Id}"), "GET", ClientIp); 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 request2 = new RequestMessage(new UrlDetails($"http://localhost/test?id={request2Id}"), "GET", ClientIp);
var response = Response.Create() var responseBuilder = Response.Create()
.WithStatusCode(200) .WithStatusCode(200)
.WithBodyAsJson(JObject.Parse("{ \"id\": \"{{request.query.id}}\" }")) .WithBodyAsJson(JObject.Parse("{ \"id\": \"{{request.query.id}}\" }"))
.WithTransformer(); .WithTransformer();
// Act // Act
var response1Message = await response.ProvideResponseAsync(request1, _settings); var response1 = await responseBuilder.ProvideResponseAsync(request1, _settings);
var response2Message = await response.ProvideResponseAsync(request2, _settings); var response2 = await responseBuilder.ProvideResponseAsync(request2, _settings);
// Assert // Assert
Check.That(((JToken)response1Message.BodyData.BodyAsJson).SelectToken("id")?.Value<int>()).IsEqualTo(request1Id); Check.That(((JToken)response1.Message.BodyData.BodyAsJson).SelectToken("id")?.Value<int>()).IsEqualTo(request1Id);
Check.That(response1Message.BodyData.BodyAsBytes).IsNull(); Check.That(response1.Message.BodyData.BodyAsBytes).IsNull();
Check.That(response1Message.BodyData.BodyAsString).IsNull(); Check.That(response1.Message.BodyData.BodyAsString).IsNull();
Check.That(response1Message.StatusCode).IsEqualTo(200); Check.That(response1.Message.StatusCode).IsEqualTo(200);
Check.That(((JToken)response2Message.BodyData.BodyAsJson).SelectToken("id")?.Value<int>()).IsEqualTo(request2Id); Check.That(((JToken)response2.Message.BodyData.BodyAsJson).SelectToken("id")?.Value<int>()).IsEqualTo(request2Id);
Check.That(response2Message.BodyData.BodyAsBytes).IsNull(); Check.That(response2.Message.BodyData.BodyAsBytes).IsNull();
Check.That(response2Message.BodyData.BodyAsString).IsNull(); Check.That(response2.Message.BodyData.BodyAsString).IsNull();
Check.That(response2Message.StatusCode).IsEqualTo(200); Check.That(response2.Message.StatusCode).IsEqualTo(200);
} }
[Fact] [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 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(response.Message.StatusCode).IsEqualTo(200);
Check.That(provideResponseAsync.BodyData.BodyAsString).Contains(fileContents); Check.That(response.Message.BodyData.BodyAsString).Contains(fileContents);
} }
[Fact] [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 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(response.Message.StatusCode).IsEqualTo(200);
Check.That(provideResponseAsync.BodyData.BodyAsString).Contains(fileContents); Check.That(response.Message.BodyData.BodyAsString).Contains(fileContents);
} }
[Fact] [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 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(response.Message.StatusCode).IsEqualTo(200);
Check.That(provideResponseAsync.BodyData.BodyAsString).Contains("File deleted."); 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 // Assign
var requestMessage = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1"); var requestMessage = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1");
var response = Response.Create() var responseBuilder = Response.Create()
.WithCallback(async request => .WithCallback(async request =>
{ {
await Task.Delay(1); await Task.Delay(1);
@@ -50,11 +50,11 @@ namespace WireMock.Net.Tests.ResponseBuilders
}); });
// Act // Act
var responseMessage = await response.ProvideResponseAsync(requestMessage, _settings); var response = await responseBuilder.ProvideResponseAsync(requestMessage, _settings);
// Assert // Assert
responseMessage.BodyData.BodyAsString.Should().Be("/fooBar"); response.Message.BodyData.BodyAsString.Should().Be("/fooBar");
responseMessage.StatusCode.Should().Be(302); response.Message.StatusCode.Should().Be(302);
} }
[Fact] [Fact]
@@ -62,7 +62,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
{ {
// Assign // Assign
var requestMessage = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1"); var requestMessage = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1");
var response = Response.Create() var responseBuilder = Response.Create()
.WithCallback(request => new ResponseMessage .WithCallback(request => new ResponseMessage
{ {
BodyData = new BodyData BodyData = new BodyData
@@ -74,11 +74,11 @@ namespace WireMock.Net.Tests.ResponseBuilders
}); });
// Act // Act
var responseMessage = await response.ProvideResponseAsync(requestMessage, _settings); var response = await responseBuilder.ProvideResponseAsync(requestMessage, _settings);
// Assert // Assert
responseMessage.BodyData.BodyAsString.Should().Be("/fooBar"); response.Message.BodyData.BodyAsString.Should().Be("/fooBar");
responseMessage.StatusCode.Should().Be(302); response.Message.StatusCode.Should().Be(302);
} }
[Fact] [Fact]
@@ -87,7 +87,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign // Assign
var header = "X-UserId"; var header = "X-UserId";
var requestMessage = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1"); var requestMessage = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1");
var response = Response.Create() var responseBuilder = Response.Create()
.WithCallback(request => new ResponseMessage .WithCallback(request => new ResponseMessage
{ {
BodyData = new BodyData BodyData = new BodyData
@@ -105,12 +105,12 @@ namespace WireMock.Net.Tests.ResponseBuilders
.WithHeader(header, "Stef"); .WithHeader(header, "Stef");
// Act // Act
var responseMessage = await response.ProvideResponseAsync(requestMessage, _settings); var response = await responseBuilder.ProvideResponseAsync(requestMessage, _settings);
// Assert // Assert
responseMessage.BodyData.BodyAsString.Should().Be("/fooBar"); response.Message.BodyData.BodyAsString.Should().Be("/fooBar");
responseMessage.StatusCode.Should().Be(HttpStatusCode.Accepted); response.Message.StatusCode.Should().Be(HttpStatusCode.Accepted);
responseMessage.Headers[header].Should().ContainSingle("Stef"); response.Message.Headers[header].Should().ContainSingle("Stef");
} }
[Fact] [Fact]
@@ -118,7 +118,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
{ {
// Assign // Assign
var requestMessage = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1"); var requestMessage = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1");
var response = Response.Create() var responseBuilder = Response.Create()
.WithCallback(request => new ResponseMessage .WithCallback(request => new ResponseMessage
{ {
BodyData = new BodyData BodyData = new BodyData
@@ -131,11 +131,11 @@ namespace WireMock.Net.Tests.ResponseBuilders
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(requestMessage, _settings); var response = await responseBuilder.ProvideResponseAsync(requestMessage, _settings);
// Assert // Assert
responseMessage.BodyData.BodyAsString.Should().Be("/fooBar"); response.Message.BodyData.BodyAsString.Should().Be("/fooBar");
responseMessage.StatusCode.Should().Be(302); 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); var request = new RequestMessage(new UrlDetails("http://localhost/fault"), "GET", ClientIp);
// Act // Act
var response = Response.Create().WithFault(faultType); var responseBuilder = Response.Create().WithFault(faultType);
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
responseMessage.FaultType.Should().Be(faultType); response.Message.FaultType.Should().Be(faultType);
responseMessage.FaultPercentage.Should().BeNull(); response.Message.FaultPercentage.Should().BeNull();
} }
[Theory] [Theory]
@@ -37,12 +37,12 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost/fault"), "GET", ClientIp); var request = new RequestMessage(new UrlDetails("http://localhost/fault"), "GET", ClientIp);
// Act // Act
var response = Response.Create().WithFault(faultType, percentage); var responseBuilder = Response.Create().WithFault(faultType, percentage);
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
responseMessage.FaultType.Should().Be(faultType); response.Message.FaultType.Should().Be(faultType);
responseMessage.FaultPercentage.Should().Be(percentage); 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 HandlebarsDotNet;
using Moq; using Moq;
using Newtonsoft.Json.Linq; using Newtonsoft.Json.Linq;
using NFluent; using NFluent;
using WireMock.Handlers; using WireMock.Handlers;
using WireMock.Models; using WireMock.Models;
using WireMock.ResponseBuilders; using WireMock.ResponseBuilders;
using WireMock.Settings; using WireMock.Settings;
using Xunit; using Xunit;
namespace WireMock.Net.Tests.ResponseBuilders namespace WireMock.Net.Tests.ResponseBuilders
{ {
public class ResponseWithHandlebarsFileTests public class ResponseWithHandlebarsFileTests
{ {
private readonly Mock<IFileSystemHandler> _filesystemHandlerMock; private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
private readonly WireMockServerSettings _settings = new WireMockServerSettings(); private readonly WireMockServerSettings _settings = new WireMockServerSettings();
private const string ClientIp = "::1"; private const string ClientIp = "::1";
public ResponseWithHandlebarsFileTests() public ResponseWithHandlebarsFileTests()
{ {
_filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict); _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
_filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc"); _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
_settings.FileSystemHandler = _filesystemHandlerMock.Object; _settings.FileSystemHandler = _filesystemHandlerMock.Object;
} }
[Fact] [Fact]
public async Task Response_ProvideResponseAsync_Handlebars_File() public async Task Response_ProvideResponseAsync_Handlebars_File()
{ {
// Assign // Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp); var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBodyAsJson(new .WithBodyAsJson(new
{ {
Data = "{{File \"x.json\"}}" Data = "{{File \"x.json\"}}"
}) })
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson); JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["Data"].Value<string>()).Equals("abc"); Check.That(j["Data"].Value<string>()).Equals("abc");
// Verify // Verify
_filesystemHandlerMock.Verify(fs => fs.ReadResponseBodyAsString("x.json"), Times.Once); _filesystemHandlerMock.Verify(fs => fs.ReadResponseBodyAsString("x.json"), Times.Once);
_filesystemHandlerMock.VerifyNoOtherCalls(); _filesystemHandlerMock.VerifyNoOtherCalls();
} }
[Fact] [Fact]
public async Task Response_ProvideResponseAsync_Handlebars_File_Replace() public async Task Response_ProvideResponseAsync_Handlebars_File_Replace()
{ {
// Assign // Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234?id=x"), "GET", ClientIp); var request = new RequestMessage(new UrlDetails("http://localhost:1234?id=x"), "GET", ClientIp);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBodyAsJson(new .WithBodyAsJson(new
{ {
Data = "{{File \"{{request.query.id}}.json\"}}" Data = "{{File \"{{request.query.id}}.json\"}}"
}) })
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson); JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["Data"].Value<string>()).Equals("abc"); Check.That(j["Data"].Value<string>()).Equals("abc");
// Verify // Verify
_filesystemHandlerMock.Verify(fs => fs.ReadResponseBodyAsString("x.json"), Times.Once); _filesystemHandlerMock.Verify(fs => fs.ReadResponseBodyAsString("x.json"), Times.Once);
_filesystemHandlerMock.VerifyNoOtherCalls(); _filesystemHandlerMock.VerifyNoOtherCalls();
} }
[Fact] [Fact]
public void Response_ProvideResponseAsync_Handlebars_File_WithMissingArgument_Throws_HandlebarsException() public void Response_ProvideResponseAsync_Handlebars_File_WithMissingArgument_Throws_HandlebarsException()
{ {
// Assign // Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp); var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBodyAsJson(new .WithBodyAsJson(new
{ {
Data = "{{File}}" Data = "{{File}}"
}) })
.WithTransformer(); .WithTransformer();
// Act // Act
Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _settings)).Throws<HandlebarsException>(); Check.ThatAsyncCode(() => responseBuilder.ProvideResponseAsync(request, _settings)).Throws<HandlebarsException>();
// Verify // Verify
_filesystemHandlerMock.Verify(fs => fs.ReadResponseBodyAsString(It.IsAny<string>()), Times.Never); _filesystemHandlerMock.Verify(fs => fs.ReadResponseBodyAsString(It.IsAny<string>()), Times.Never);
_filesystemHandlerMock.VerifyNoOtherCalls(); _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 request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBody("{{String.Uppercase request.body}}") .WithBody("{{String.Uppercase request.body}}")
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// assert // 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 request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create() var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/json") .WithHeader("Content-Type", "application/json")
.WithBodyAsJson(new { x = "{{JsonPath.SelectToken request.body \"$.Manufacturers[?(@.Name == 'Acme Co')]\"}}" }) .WithBodyAsJson(new { x = "{{JsonPath.SelectToken request.body \"$.Manufacturers[?(@.Name == 'Acme Co')]\"}}" })
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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"]).IsNotNull();
Check.That(j["x"]["Name"].ToString()).Equals("Acme Co"); 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 request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create() var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/json") .WithHeader("Content-Type", "application/json")
.WithBodyAsJson(new { x = "{{JsonPath.SelectToken request.body \"..Price\"}}" }) .WithBodyAsJson(new { x = "{{JsonPath.SelectToken request.body \"..Price\"}}" })
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson); JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["x"].Value<long>()).Equals(99); 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 request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create() var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/json") .WithHeader("Content-Type", "application/json")
.WithBody("{{JsonPath.SelectToken request.body \"$.Manufacturers[?(@.Name == 'Acme Co')]\"}}") .WithBody("{{JsonPath.SelectToken request.body \"$.Manufacturers[?(@.Name == 'Acme Co')]\"}}")
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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] [Fact]
@@ -204,16 +204,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body); 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") .WithHeader("Content-Type", "application/json")
.WithBody("{{JsonPath.SelectToken request.bodyAsJson \"$.Manufacturers[?(@.Name == 'Acme Co')]\"}}") .WithBody("{{JsonPath.SelectToken request.bodyAsJson \"$.Manufacturers[?(@.Name == 'Acme Co')]\"}}")
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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] [Fact]
@@ -257,16 +257,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body); 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") .WithHeader("Content-Type", "application/json")
.WithBody("{{#JsonPath.SelectTokens request.body \"$..Products[?(@.Price >= 50)].Name\"}}{{#each this}}%{{@index}}:{{this}}%{{/each}}{{/JsonPath.SelectTokens}}") .WithBody("{{#JsonPath.SelectTokens request.body \"$..Products[?(@.Price >= 50)].Name\"}}{{#each this}}%{{@index}}:{{this}}%{{/each}}{{/JsonPath.SelectTokens}}")
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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] [Fact]
@@ -310,16 +310,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body); 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") .WithHeader("Content-Type", "application/json")
.WithBody("{{#JsonPath.SelectTokens request.bodyAsJson \"$..Products[?(@.Price >= 50)].Name\"}}{{#each this}}%{{@index}}:{{this}}%{{/each}}{{/JsonPath.SelectTokens}}") .WithBody("{{#JsonPath.SelectTokens request.bodyAsJson \"$..Products[?(@.Price >= 50)].Name\"}}{{#each this}}%{{@index}}:{{this}}%{{/each}}{{/JsonPath.SelectTokens}}")
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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] [Fact]
@@ -339,13 +339,13 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body); 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") .WithHeader("Content-Type", "application/json")
.WithBody("{{#JsonPath.SelectTokens request.body \"$..Products[?(@.Price >= 50)].Name\"}}{{id}} {{value}},{{/JsonPath.SelectTokens}}") .WithBody("{{#JsonPath.SelectTokens request.body \"$..Products[?(@.Price >= 50)].Name\"}}{{id}} {{value}},{{/JsonPath.SelectTokens}}")
.WithTransformer(); .WithTransformer();
// Act // Act
Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _settings)).Throws<ArgumentNullException>(); Check.ThatAsyncCode(() => responseBuilder.ProvideResponseAsync(request, _settings)).Throws<ArgumentNullException>();
} }
[Fact] [Fact]
@@ -364,15 +364,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, bodyData); var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, bodyData);
string jsonPath = "\"$.MyUniqueNumber\""; string jsonPath = "\"$.MyUniqueNumber\"";
var response = Response.Create() var responseBuilder = Response.Create()
.WithTransformer() .WithTransformer()
.WithBodyFromFile(@"c:\\{{JsonPath.SelectToken request.body " + jsonPath + "}}\\test.json"); // why use a \\ here ? .WithBodyFromFile(@"c:\\{{JsonPath.SelectToken request.body " + jsonPath + "}}\\test.json"); // why use a \\ here ?
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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;
using System.Threading.Tasks; using System.Threading.Tasks;
using FluentAssertions; using FluentAssertions;
using HandlebarsDotNet; using HandlebarsDotNet;
using Moq; using Moq;
using Newtonsoft.Json.Linq; using Newtonsoft.Json.Linq;
using NFluent; using NFluent;
using WireMock.Handlers; using WireMock.Handlers;
using WireMock.Models; using WireMock.Models;
using WireMock.ResponseBuilders; using WireMock.ResponseBuilders;
using WireMock.Settings; using WireMock.Settings;
using WireMock.Types; using WireMock.Types;
using WireMock.Util; using WireMock.Util;
using Xunit; using Xunit;
namespace WireMock.Net.Tests.ResponseBuilders namespace WireMock.Net.Tests.ResponseBuilders
{ {
public class ResponseWithHandlebarsLinqTests public class ResponseWithHandlebarsLinqTests
{ {
private readonly Mock<IFileSystemHandler> _filesystemHandlerMock; private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
private readonly WireMockServerSettings _settings = new WireMockServerSettings(); private readonly WireMockServerSettings _settings = new WireMockServerSettings();
public ResponseWithHandlebarsLinqTests() public ResponseWithHandlebarsLinqTests()
{ {
_filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict); _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
_filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc"); _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
_settings.FileSystemHandler = _filesystemHandlerMock.Object; _settings.FileSystemHandler = _filesystemHandlerMock.Object;
} }
[Fact] [Fact]
public async Task Response_ProvideResponse_Handlebars_Linq1_String0() public async Task Response_ProvideResponse_Handlebars_Linq1_String0()
{ {
// Assign // Assign
var body = new BodyData(); var body = new BodyData();
var request = new RequestMessage(new UrlDetails("http://localhost:1234/pathtest"), "POST", "::1", body); var request = new RequestMessage(new UrlDetails("http://localhost:1234/pathtest"), "POST", "::1", body);
var response = Response.Create() var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/json") .WithHeader("Content-Type", "application/json")
.WithBodyAsJson(new { x = "{{Linq request.Path 'it'}}" }) .WithBodyAsJson(new { x = "{{Linq request.Path 'it'}}" })
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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"]).IsNotNull();
Check.That(j["x"].ToString()).Equals("/pathtest"); Check.That(j["x"].ToString()).Equals("/pathtest");
} }
[Fact] [Fact]
public async Task Response_ProvideResponse_Handlebars_Linq1_String1() public async Task Response_ProvideResponse_Handlebars_Linq1_String1()
{ {
// Assign // Assign
var body = new BodyData var body = new BodyData
{ {
BodyAsJson = new JObject BodyAsJson = new JObject
{ {
{ "Id", new JValue(9) }, { "Id", new JValue(9) },
{ "Name", new JValue("Test") } { "Name", new JValue("Test") }
}, },
DetectedBodyType = BodyType.Json DetectedBodyType = BodyType.Json
}; };
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body); var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var response = Response.Create() var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/json") .WithHeader("Content-Type", "application/json")
.WithBodyAsJson(new { x = "{{Linq request.bodyAsJson 'it.Name + \"_123\"' }}" }) .WithBodyAsJson(new { x = "{{Linq request.bodyAsJson 'it.Name + \"_123\"' }}" })
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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"]).IsNotNull();
Check.That(j["x"].ToString()).Equals("Test_123"); Check.That(j["x"].ToString()).Equals("Test_123");
} }
[Fact] [Fact]
public async Task Response_ProvideResponse_Handlebars_Linq1_String2() public async Task Response_ProvideResponse_Handlebars_Linq1_String2()
{ {
// Assign // Assign
var body = new BodyData var body = new BodyData
{ {
BodyAsJson = new JObject BodyAsJson = new JObject
{ {
{ "Id", new JValue(9) }, { "Id", new JValue(9) },
{ "Name", new JValue("Test") } { "Name", new JValue("Test") }
}, },
DetectedBodyType = BodyType.Json DetectedBodyType = BodyType.Json
}; };
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body); var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var response = Response.Create() var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/json") .WithHeader("Content-Type", "application/json")
.WithBodyAsJson(new { x = "{{Linq request.bodyAsJson 'new(it.Name + \"_123\" as N, it.Id as I)' }}" }) .WithBodyAsJson(new { x = "{{Linq request.bodyAsJson 'new(it.Name + \"_123\" as N, it.Id as I)' }}" })
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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"]).IsNotNull();
Check.That(j["x"].ToString()).Equals("{ N = Test_123, I = 9 }"); Check.That(j["x"].ToString()).Equals("{ N = Test_123, I = 9 }");
} }
[Fact] [Fact]
public async Task Response_ProvideResponse_Handlebars_Linq2_Object() public async Task Response_ProvideResponse_Handlebars_Linq2_Object()
{ {
// Assign // Assign
var body = new BodyData var body = new BodyData
{ {
BodyAsJson = new JObject BodyAsJson = new JObject
{ {
{ "Id", new JValue(9) }, { "Id", new JValue(9) },
{ "Name", new JValue("Test") } { "Name", new JValue("Test") }
}, },
DetectedBodyType = BodyType.Json DetectedBodyType = BodyType.Json
}; };
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body); var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var response = Response.Create() var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/json") .WithHeader("Content-Type", "application/json")
.WithBodyAsJson(new { x = "{{#Linq request.bodyAsJson 'new(it.Name + \"_123\" as N, it.Id as I)' }}{{this}}{{/Linq}}" }) .WithBodyAsJson(new { x = "{{#Linq request.bodyAsJson 'new(it.Name + \"_123\" as N, it.Id as I)' }}{{this}}{{/Linq}}" })
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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"]).IsNotNull();
Check.That(j["x"].ToString()).Equals("{ N = Test_123, I = 9 }"); Check.That(j["x"].ToString()).Equals("{ N = Test_123, I = 9 }");
} }
[Fact] [Fact]
public void Response_ProvideResponse_Handlebars_Linq_Throws_ArgumentException() public void Response_ProvideResponse_Handlebars_Linq_Throws_ArgumentException()
{ {
// Assign // Assign
var body = new BodyData var body = new BodyData
{ {
BodyAsJson = new { x = "x" }, BodyAsJson = new { x = "x" },
DetectedBodyType = BodyType.Json DetectedBodyType = BodyType.Json
}; };
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body); var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBodyAsJson(new { x = "{{Linq request.bodyAsJson 1}}" }) .WithBodyAsJson(new { x = "{{Linq request.bodyAsJson 1}}" })
.WithTransformer(); .WithTransformer();
// Act // Act
Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _settings)).Throws<ArgumentException>(); Check.ThatAsyncCode(() => responseBuilder.ProvideResponseAsync(request, _settings)).Throws<ArgumentException>();
} }
[Fact] [Fact]
public void Response_ProvideResponse_Handlebars_Linq1_Throws_ArgumentNullException() public void Response_ProvideResponse_Handlebars_Linq1_Throws_ArgumentNullException()
{ {
// Assign // Assign
var body = new BodyData(); var body = new BodyData();
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body); var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBodyAsJson(new { x = "{{Linq request.body 'Name'}}" }) .WithBodyAsJson(new { x = "{{Linq request.body 'Name'}}" })
.WithTransformer(); .WithTransformer();
// Act // Act
Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _settings)).Throws<ArgumentNullException>(); Check.ThatAsyncCode(() => responseBuilder.ProvideResponseAsync(request, _settings)).Throws<ArgumentNullException>();
} }
[Fact] [Fact]
public void Response_ProvideResponse_Handlebars_Linq1_Throws_HandlebarsException() public void Response_ProvideResponse_Handlebars_Linq1_Throws_HandlebarsException()
{ {
// Assign // Assign
var body = new BodyData(); var body = new BodyData();
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body); var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBodyAsJson(new { x = "{{Linq request.bodyAsJson}} ''" }) .WithBodyAsJson(new { x = "{{Linq request.bodyAsJson}} ''" })
.WithTransformer(); .WithTransformer();
// Act // Act
Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _settings)).Throws<HandlebarsException>(); Check.ThatAsyncCode(() => responseBuilder.ProvideResponseAsync(request, _settings)).Throws<HandlebarsException>();
} }
[Fact] [Fact]
public void Response_ProvideResponse_Handlebars_Linq1_ParseError_Throws_ExceptionMessage() public void Response_ProvideResponse_Handlebars_Linq1_ParseError_Throws_ExceptionMessage()
{ {
// Assign // Assign
var body = new BodyData var body = new BodyData
{ {
BodyAsJson = new JObject BodyAsJson = new JObject
{ {
{ "Id", new JValue(9) }, { "Id", new JValue(9) },
{ "Name", new JValue("Test") } { "Name", new JValue("Test") }
}, },
DetectedBodyType = BodyType.Json DetectedBodyType = BodyType.Json
}; };
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body); var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBodyAsJson(new { x = "{{Linq request.bodyAsJson '---' }}" }) .WithBodyAsJson(new { x = "{{Linq request.bodyAsJson '---' }}" })
.WithTransformer(); .WithTransformer();
// Act // Act
Func<Task> a = async () => await response.ProvideResponseAsync(request, _settings); Func<Task> a = async () => await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
a.Should().Throw<HandlebarsException>(); a.Should().Throw<HandlebarsException>();
} }
[Fact] [Fact]
public void Response_ProvideResponse_Handlebars_Linq2_ParseError_Throws_ExceptionMessage() public void Response_ProvideResponse_Handlebars_Linq2_ParseError_Throws_ExceptionMessage()
{ {
// Assign // Assign
var body = new BodyData var body = new BodyData
{ {
BodyAsJson = new JObject BodyAsJson = new JObject
{ {
{ "Id", new JValue(9) }, { "Id", new JValue(9) },
{ "Name", new JValue("Test") } { "Name", new JValue("Test") }
}, },
DetectedBodyType = BodyType.Json DetectedBodyType = BodyType.Json
}; };
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body); var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", "::1", body);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBodyAsJson(new { x = "{{#Linq request.bodyAsJson '---' }}{{this}}{{/Linq}}" }) .WithBodyAsJson(new { x = "{{#Linq request.bodyAsJson '---' }}{{this}}{{/Linq}}" })
.WithTransformer(); .WithTransformer();
// Act // Act
Func<Task> a = async () => await response.ProvideResponseAsync(request, _settings); Func<Task> a = async () => await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
a.Should().Throw<HandlebarsException>(); a.Should().Throw<HandlebarsException>();
} }
} }
} }

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

@@ -32,7 +32,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign // Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp); var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBodyAsJson(new .WithBodyAsJson(new
{ {
Text = "{{Random Type=\"Text\" Min=8 Max=20}}", Text = "{{Random Type=\"Text\" Min=8 Max=20}}",
@@ -43,10 +43,10 @@ namespace WireMock.Net.Tests.ResponseBuilders
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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["Text"].Value<string>()).IsNotEmpty();
Check.That(j["Integer"].Value<int>()).IsEqualTo(1000); Check.That(j["Integer"].Value<int>()).IsEqualTo(1000);
Check.That(j["Long"].Value<long>()).IsStrictlyGreaterThan(77777777).And.IsStrictlyLessThan(99999999); Check.That(j["Long"].Value<long>()).IsStrictlyGreaterThan(77777777).And.IsStrictlyLessThan(99999999);
@@ -58,7 +58,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign // Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp); var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBodyAsJson(new .WithBodyAsJson(new
{ {
Value = "{{Random Type=\"Boolean\"}}" Value = "{{Random Type=\"Boolean\"}}"
@@ -66,10 +66,10 @@ namespace WireMock.Net.Tests.ResponseBuilders
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson); JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
Check.That(j["Value"].Type).IsEqualTo(JTokenType.Boolean); Check.That(j["Value"].Type).IsEqualTo(JTokenType.Boolean);
} }
@@ -79,7 +79,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign // Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp); var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBodyAsJson(new .WithBodyAsJson(new
{ {
Guid1 = "{{Random Type=\"Guid\" Uppercase=false}}", Guid1 = "{{Random Type=\"Guid\" Uppercase=false}}",
@@ -88,10 +88,10 @@ namespace WireMock.Net.Tests.ResponseBuilders
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson); JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
string guid1 = j["Guid1"].Value<string>(); string guid1 = j["Guid1"].Value<string>();
Check.That(guid1.ToUpper()).IsNotEqualTo(guid1); Check.That(guid1.ToUpper()).IsNotEqualTo(guid1);
string guid2 = j["Guid2"].Value<string>(); string guid2 = j["Guid2"].Value<string>();
@@ -104,7 +104,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign // Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp); var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBodyAsJson(new .WithBodyAsJson(new
{ {
StringValue = "{{Random Type=\"StringList\" Values=[\"a\", \"b\", \"c\"]}}" StringValue = "{{Random Type=\"StringList\" Values=[\"a\", \"b\", \"c\"]}}"
@@ -112,10 +112,10 @@ namespace WireMock.Net.Tests.ResponseBuilders
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson); JObject j = JObject.FromObject(response.Message.BodyData.BodyAsJson);
string value = j["StringValue"].Value<string>(); string value = j["StringValue"].Value<string>();
Check.That(new[] { "a", "b", "c" }.Contains(value)).IsTrue(); Check.That(new[] { "a", "b", "c" }.Contains(value)).IsTrue();
} }
@@ -126,7 +126,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign // Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp); var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBodyAsJson(new .WithBodyAsJson(new
{ {
Integer = "{{#Random Type=\"Integer\" Min=10000000 Max=99999999}}{{this}}{{/Random}}", Integer = "{{#Random Type=\"Integer\" Min=10000000 Max=99999999}}{{this}}{{/Random}}",
@@ -134,10 +134,10 @@ namespace WireMock.Net.Tests.ResponseBuilders
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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); 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 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+)$\"}}") .WithBody("{{Regex.Match request.body \"^(\\w+)$\"}}")
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// assert // assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("abc"); Check.That(response.Message.BodyData.BodyAsString).Equals("abc");
} }
[Fact] [Fact]
@@ -54,15 +54,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body); 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$\"}}") .WithBody("{{Regex.Match request.body \"^?0$\"}}")
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// assert // assert
Check.That(responseMessage.BodyData.BodyAsString).Equals(""); Check.That(response.Message.BodyData.BodyAsString).Equals("");
} }
[Fact] [Fact]
@@ -73,15 +73,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body); 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\"}}") .WithBody("{{Regex.Match request.body \"^?0$\" \"d\"}}")
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// assert // assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("d"); Check.That(response.Message.BodyData.BodyAsString).Equals("d");
} }
[Fact] [Fact]
@@ -92,15 +92,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body); 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}}") .WithBody("{{#Regex.Match request.body \"^(?<proto>\\w+)://[^/]+?(?<port>\\d+)/?\"}}{{this.port}}-{{this.proto}}{{/Regex.Match}}")
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// assert // assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("5000-https"); Check.That(response.Message.BodyData.BodyAsString).Equals("5000-https");
} }
[Fact] [Fact]
@@ -111,15 +111,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body); 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}}") .WithBody("{{#Regex.Match request.body \"^(?<proto>\\w+)://[^/]+?(?<port>\\d+)/?\"}}{{this}}{{/Regex.Match}}")
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// assert // assert
Check.That(responseMessage.BodyData.BodyAsString).Equals(""); Check.That(response.Message.BodyData.BodyAsString).Equals("");
} }
[Fact] [Fact]
@@ -130,15 +130,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body); 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}}") .WithBody("{{#Regex.Match request.body \"^(?<proto>\\w+)://[^/]+?(?<port>\\d+)/?\" \"x\"}}{{this}}{{/Regex.Match}}")
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// assert // assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("x"); Check.That(response.Message.BodyData.BodyAsString).Equals("x");
} }
[Fact] [Fact]
@@ -149,12 +149,12 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body); 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}}") .WithBody("{{#Regex.Match request.bodyAsJson \"^(?<proto>\\w+)://[^/]+?(?<port>\\d+)/?\"}}{{/Regex.Match}}")
.WithTransformer(); .WithTransformer();
// Act and Assert // 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 request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create() var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/xml") .WithHeader("Content-Type", "application/xml")
.WithBody("<response>{{XPath.SelectSingleNode request.body \"/todo-list/todo-item[1]\"}}</response>") .WithBody("<response>{{XPath.SelectSingleNode request.body \"/todo-list/todo-item[1]\"}}</response>")
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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"); var node = nav.XPath2SelectSingleNode("/response/todo-item");
Check.That(node.Value).Equals("abc"); Check.That(node.Value).Equals("abc");
Check.That(node.GetAttribute("id", "")).Equals("a1"); 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 request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create() var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/xml") .WithHeader("Content-Type", "application/xml")
.WithBody("{{XPath.SelectSingleNode request.body \"/todo-list/todo-item[1]/text()\"}}") .WithBody("{{XPath.SelectSingleNode request.body \"/todo-list/todo-item[1]/text()\"}}")
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(responseMessage.BodyData.BodyAsString).IsEqualTo("abc"); Check.That(response.Message.BodyData.BodyAsString).IsEqualTo("abc");
} }
[Fact] [Fact]
@@ -105,16 +105,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body); 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") .WithHeader("Content-Type", "application/xml")
.WithBody("<response>{{XPath.SelectNodes request.body \"/todo-list/todo-item\"}}</response>") .WithBody("<response>{{XPath.SelectNodes request.body \"/todo-list/todo-item\"}}</response>")
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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"); var nodes = nav.XPath2SelectNodes("/response/todo-item");
Check.That(nodes.Count + 1).IsEqualTo(3); 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 request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body);
var response = Response.Create() var responseBuilder = Response.Create()
.WithHeader("Content-Type", "application/xml") .WithHeader("Content-Type", "application/xml")
.WithBody("{{XPath.Evaluate request.body \"boolean(/todo-list[count(todo-item) = 3])\"}}") .WithBody("{{XPath.Evaluate request.body \"boolean(/todo-list[count(todo-item) = 3])\"}}")
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(responseMessage.BodyData.BodyAsString).IsEqualIgnoringCase("True"); Check.That(response.Message.BodyData.BodyAsString).IsEqualIgnoringCase("True");
} }
[Fact] [Fact]
@@ -163,16 +163,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body); 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") .WithHeader("Content-Type", "application/xml")
.WithBody("{{XPath.Evaluate request.body \"string(/todo-list/todo-item[1]/@id)\"}}") .WithBody("{{XPath.Evaluate request.body \"string(/todo-list/todo-item[1]/@id)\"}}")
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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 // Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp); var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBodyAsJson(new .WithBodyAsJson(new
{ {
Number = "{{Xeger.Generate \"[1-9]{1}\\d{3}\"}}", Number = "{{Xeger.Generate \"[1-9]{1}\\d{3}\"}}",
@@ -40,10 +40,10 @@ namespace WireMock.Net.Tests.ResponseBuilders
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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["Number"].Value<int>()).IsStrictlyGreaterThan(1000).And.IsStrictlyLessThan(9999);
Check.That(j["Postcode"].Value<string>()).IsNotEmpty(); Check.That(j["Postcode"].Value<string>()).IsNotEmpty();
} }
@@ -54,7 +54,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign // Assign
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp); var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBodyAsJson(new .WithBodyAsJson(new
{ {
Number = "{{#Xeger.Generate \"[1-9]{1}\\d{3}\"}}{{this}}{{/Xeger.Generate}}", Number = "{{#Xeger.Generate \"[1-9]{1}\\d{3}\"}}{{this}}{{/Xeger.Generate}}",
@@ -63,10 +63,10 @@ namespace WireMock.Net.Tests.ResponseBuilders
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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["Number"].Value<int>()).IsStrictlyGreaterThan(1000).And.IsStrictlyLessThan(9999);
Check.That(j["Postcode"].Value<string>()).IsNotEmpty(); 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); var response = await builder.ProvideResponseAsync(requestMock, _settings);
// Assert // Assert
Check.That(response.Headers[headerName].ToString()).Equals(headerValue); Check.That(response.Message.Headers[headerName].ToString()).Equals(headerValue);
} }
[Theory] [Theory]
@@ -44,7 +44,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
var response = await builder.ProvideResponseAsync(requestMock, _settings); var response = await builder.ProvideResponseAsync(requestMock, _settings);
// Assert // Assert
Check.That(response.Headers[headerName].ToArray()).Equals(headerValues); Check.That(response.Message.Headers[headerName].ToArray()).Equals(headerValues);
} }
[Fact] [Fact]
@@ -59,7 +59,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
var responseMessage = await response.ProvideResponseAsync(request, _settings); var responseMessage = await response.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(responseMessage.Headers["h"]).ContainsExactly("x"); Check.That(responseMessage.Message.Headers["h"]).ContainsExactly("x");
} }
[Fact] [Fact]
@@ -68,13 +68,13 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign // Assign
var request = new RequestMessage(new UrlDetails("http://localhost"), "GET", ClientIp); var request = new RequestMessage(new UrlDetails("http://localhost"), "GET", ClientIp);
var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } }; var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
var response = Response.Create().WithHeaders(headers); var responseBuilder = Response.Create().WithHeaders(headers);
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(responseMessage.Headers["h"]).ContainsExactly("x"); Check.That(response.Message.Headers["h"]).ContainsExactly("x");
} }
[Fact] [Fact]
@@ -83,13 +83,13 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign // Assign
var request = new RequestMessage(new UrlDetails("http://localhost"), "GET", ClientIp); var request = new RequestMessage(new UrlDetails("http://localhost"), "GET", ClientIp);
var headers = new Dictionary<string, WireMockList<string>> { { "h", new WireMockList<string>("x") } }; 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 // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await builder.ProvideResponseAsync(request, _settings);
// Assert // 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 // Assign
var headers = new Dictionary<string, string[]> { { "Content-Type", new[] { "application/xml" } } }; 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 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 // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(request.ProxyUrl).IsNotNull(); Check.That(request.ProxyUrl).IsNotNull();
Check.That(responseMessage.BodyData.BodyAsString).IsEqualTo(expectedBody); Check.That(response.Message.BodyData.BodyAsString).IsEqualTo(expectedBody);
Check.That(responseMessage.StatusCode).IsEqualTo(201); Check.That(response.Message.StatusCode).IsEqualTo(201);
Check.That(responseMessage.Headers["Content-Type"].ToString()).IsEqualTo("application/json"); Check.That(response.Message.Headers["Content-Type"].ToString()).IsEqualTo("application/json");
} }
[Fact] [Fact]
@@ -72,12 +72,12 @@ namespace WireMock.Net.Tests.ResponseBuilders
Password = "y" Password = "y"
} }
}; };
var response = Response.Create().WithProxy(settings); var responseBuilder = Response.Create().WithProxy(settings);
// Act // Act
var request = new RequestMessage(new UrlDetails($"{_server.Urls[0]}/{_guid}"), "GET", ClientIp); 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() 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 urlDetails = UrlUtils.Parse(new Uri("http://localhost/wiremock/a/b"), new PathString("/wiremock"));
var request = new RequestMessage(urlDetails, "GET", ClientIp); var request = new RequestMessage(urlDetails, "GET", ClientIp);
var response = Response.Create().WithTransformer(TransformerType.ScribanDotLiquid); var responseBuilder = Response.Create().WithTransformer(TransformerType.ScribanDotLiquid);
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
responseMessage.BodyData.Should().BeNull(); response.Message.BodyData.Should().BeNull();
} }
[Fact] [Fact]
@@ -60,15 +60,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
}; };
var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POSt", ClientIp, body); 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}}") .WithBody("test {{request.Url}} {{request.Path}} {{request.Method}}")
.WithTransformer(TransformerType.Scriban); .WithTransformer(TransformerType.Scriban);
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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); var request = new RequestMessage(new UrlDetails("http://localhost/fault"), "GET", ClientIp);
// Act // Act
var response = Response.Create(); var responseBuilder = Response.Create();
switch (statusCode) switch (statusCode)
{ {
case string statusCodeAsString: case string statusCodeAsString:
response = response.WithStatusCode(statusCodeAsString); responseBuilder = responseBuilder.WithStatusCode(statusCodeAsString);
break; break;
case int statusCodeAInteger: case int statusCodeAInteger:
response = response.WithStatusCode(statusCodeAInteger); responseBuilder = responseBuilder.WithStatusCode(statusCodeAInteger);
break; break;
case HttpStatusCode statusCodeAsEnum: case HttpStatusCode statusCodeAsEnum:
response = response.WithStatusCode(statusCodeAsEnum); responseBuilder = responseBuilder.WithStatusCode(statusCodeAsEnum);
break; break;
} }
var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object); var response = await responseBuilder.ProvideResponseAsync(request, _settingsMock.Object);
// Assert // 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 urlDetails = UrlUtils.Parse(new Uri("http://localhost/wiremock/a/b"), new PathString("/wiremock"));
var request = new RequestMessage(urlDetails, "GET", ClientIp); var request = new RequestMessage(urlDetails, "GET", ClientIp);
var response = Response.Create().WithTransformer(transformerType); var responseBuilder = Response.Create().WithTransformer(transformerType);
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
responseMessage.BodyData.Should().BeNull(); response.Message.BodyData.Should().BeNull();
} }
[Theory] [Theory]
@@ -69,15 +69,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
}; };
var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POSt", ClientIp, body); 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}}") .WithBody("test {{request.Url}} {{request.Path}} {{request.Method}}")
.WithTransformer(transformerType); .WithTransformer(transformerType);
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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] [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 urlDetails = UrlUtils.Parse(new Uri("http://localhost/wiremock/a/b"), new PathString("/wiremock"));
var request = new RequestMessage(urlDetails, httpMethod, ClientIp); 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}}") .WithBody("url={{request.Url}} absoluteurl={{request.AbsoluteUrl}} path={{request.Path}} absolutepath={{request.AbsolutePath}}")
.WithTransformer(transformerType); .WithTransformer(transformerType);
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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] [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 urlDetails = UrlUtils.Parse(new Uri("http://localhost/wiremock/a/b"), new PathString("/wiremock"));
var request = new RequestMessage(urlDetails, "POST", ClientIp); var request = new RequestMessage(urlDetails, "POST", ClientIp);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBody("{{request.PathSegments.[0]}} {{request.AbsolutePathSegments.[0]}}") .WithBody("{{request.PathSegments.[0]}} {{request.AbsolutePathSegments.[0]}}")
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("a wiremock"); Check.That(response.Message.BodyData.BodyAsString).Equals("a wiremock");
} }
[Theory(Skip = "Invalid token `OpenBracket`")] [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 urlDetails = UrlUtils.Parse(new Uri("http://localhost/wiremock/a/b"), new PathString("/wiremock"));
var request = new RequestMessage(urlDetails, "POST", ClientIp); var request = new RequestMessage(urlDetails, "POST", ClientIp);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBody("{{request.PathSegments.[0]}} {{request.AbsolutePathSegments.[0]}}") .WithBody("{{request.PathSegments.[0]}} {{request.AbsolutePathSegments.[0]}}")
.WithTransformer(transformerType); .WithTransformer(transformerType);
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("a wiremock"); Check.That(response.Message.BodyData.BodyAsString).Equals("a wiremock");
} }
[Fact] [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 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}}") .WithBody("test keya={{request.query.a}} idx={{request.query.a.[0]}} idx={{request.query.a.[1]}} keyb={{request.query.b}}")
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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`")] [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 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}}") .WithBody("test keya={{request.query.a}} idx={{request.query.a.[0]}} idx={{request.query.a.[1]}} keyb={{request.query.b}}")
.WithTransformer(transformerType); .WithTransformer(transformerType);
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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] [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 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}}") .WithStatusCode("{{request.query.a}}")
.WithBody("test") .WithBody("test")
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("test"); Check.That(response.Message.BodyData.BodyAsString).Equals("test");
Check.That(responseMessage.StatusCode).Equals("400"); Check.That(response.Message.StatusCode).Equals("400");
} }
[Theory(Skip = "WireMockList is not supported by Scriban")] [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 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}}") .WithStatusCode("{{request.Query.a}}")
.WithBody("test") .WithBody("test")
.WithTransformer(transformerType); .WithTransformer(transformerType);
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("test"); Check.That(response.Message.BodyData.BodyAsString).Equals("test");
Check.That(responseMessage.StatusCode).Equals("400"); Check.That(response.Message.StatusCode).Equals("400");
} }
[Theory] [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 request = new RequestMessage(new UrlDetails("http://localhost/foo?a=400"), "POST", ClientIp, body);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBody("test") .WithBody("test")
.WithTransformer(transformerType); .WithTransformer(transformerType);
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("test"); Check.That(response.Message.BodyData.BodyAsString).Equals("test");
Check.That(responseMessage.StatusCode).Equals(null); Check.That(response.Message.StatusCode).Equals(null);
} }
[Fact] [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 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 // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("test"); Check.That(response.Message.BodyData.BodyAsString).Equals("test");
Check.That(responseMessage.Headers).ContainsKey("x"); Check.That(response.Message.Headers).ContainsKey("x");
Check.That(responseMessage.Headers["x"]).ContainsExactly("text/plain"); Check.That(response.Message.Headers["x"]).ContainsExactly("text/plain");
} }
[Fact] [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 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 // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("test"); Check.That(response.Message.BodyData.BodyAsString).Equals("test");
Check.That(responseMessage.Headers).ContainsKey("x"); Check.That(response.Message.Headers).ContainsKey("x");
Check.That(responseMessage.Headers["x"]).Contains("text/plain"); Check.That(response.Message.Headers["x"]).Contains("text/plain");
Check.That(responseMessage.Headers["x"]).Contains("http://localhost/foo"); Check.That(response.Message.Headers["x"]).Contains("http://localhost/foo");
} }
[Theory(Skip = "WireMockList is not supported by Scriban")] [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 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 // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(responseMessage.BodyData.BodyAsString).Equals("test"); Check.That(response.Message.BodyData.BodyAsString).Equals("test");
Check.That(responseMessage.Headers).ContainsKey("x"); Check.That(response.Message.Headers).ContainsKey("x");
Check.That(responseMessage.Headers["x"]).Contains("text/plain"); Check.That(response.Message.Headers["x"]).Contains("text/plain");
Check.That(responseMessage.Headers["x"]).Contains("http://localhost/foo"); Check.That(response.Message.Headers["x"]).Contains("http://localhost/foo");
} }
[Theory] [Theory]
@@ -348,15 +348,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
}; };
var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "POST", ClientIp, body); 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}}") .WithBody("test {{request.Origin}} {{request.Port}} {{request.Protocol}} {{request.Host}}")
.WithTransformer(transformerType); .WithTransformer(transformerType);
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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] [Theory]
@@ -375,15 +375,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
}; };
var request = new RequestMessage(new UrlDetails("http://localhost/foo_object"), "POST", ClientIp, bodyData); 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}}" }) .WithBodyAsJson(new { x = "test {{request.Path}}" })
.WithTransformer(transformerType); .WithTransformer(transformerType);
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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] [Theory]
@@ -402,15 +402,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
}; };
var request = new RequestMessage(new UrlDetails("http://localhost/foo_array"), "POST", ClientIp, bodyData); 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" }) .WithBodyAsJson(new[] { "first", "{{request.path}}", "{{request.bodyAsJson.a}}", "{{request.bodyAsJson.b}}", "last" })
.WithTransformer(transformerType); .WithTransformer(transformerType);
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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] [Fact]
@@ -419,15 +419,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign // Assign
var request = new RequestMessage(new UrlDetails("http://localhost/foo?MyUniqueNumber=1"), "GET", ClientIp); var request = new RequestMessage(new UrlDetails("http://localhost/foo?MyUniqueNumber=1"), "GET", ClientIp);
var response = Response.Create() var responseBuilder = Response.Create()
.WithTransformer() .WithTransformer()
.WithBodyFromFile(@"c:\\{{request.query.MyUniqueNumber}}\\test.xml"); .WithBodyFromFile(@"c:\\{{request.query.MyUniqueNumber}}\\test.xml");
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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")] [Theory(Skip = @"Does not work in Scriban --> c:\\[""1""]\\test.xml")]
@@ -438,15 +438,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
// Assign // Assign
var request = new RequestMessage(new UrlDetails("http://localhost/foo?MyUniqueNumber=1"), "GET", ClientIp); var request = new RequestMessage(new UrlDetails("http://localhost/foo?MyUniqueNumber=1"), "GET", ClientIp);
var response = Response.Create() var responseBuilder = Response.Create()
.WithTransformer(transformerType) .WithTransformer(transformerType)
.WithBodyFromFile(@"c:\\{{request.query.MyUniqueNumber}}\\test.xml"); .WithBodyFromFile(@"c:\\{{request.query.MyUniqueNumber}}\\test.xml");
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(responseMessage.BodyData.BodyAsFile).Equals(@"c:\1\test.xml"); Check.That(response.Message.BodyData.BodyAsFile).Equals(@"c:\1\test.xml");
} }
[Theory] [Theory]
@@ -463,17 +463,17 @@ namespace WireMock.Net.Tests.ResponseBuilders
var request = new RequestMessage(new UrlDetails("http://localhost/foo?MyUniqueNumber=1"), "GET", ClientIp); var request = new RequestMessage(new UrlDetails("http://localhost/foo?MyUniqueNumber=1"), "GET", ClientIp);
var response = Response.Create() var responseBuilder = Response.Create()
.WithTransformer(transformerType, true) .WithTransformer(transformerType, true)
.WithBodyFromFile(@"c:\\{{request.query.MyUniqueNumber}}\\test.xml"); .WithBodyFromFile(@"c:\\{{request.query.MyUniqueNumber}}\\test.xml");
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(responseMessage.BodyData.BodyAsFile).Equals(@"c:\1\test.xml"); Check.That(response.Message.BodyData.BodyAsFile).Equals(@"c:\1\test.xml");
Check.That(responseMessage.BodyData.DetectedBodyType).Equals(BodyType.String); Check.That(response.Message.BodyData.DetectedBodyType).Equals(BodyType.String);
Check.That(responseMessage.BodyData.BodyAsString).Equals("<xml MyUniqueNumber=\"1\"></xml>"); Check.That(response.Message.BodyData.BodyAsString).Equals("<xml MyUniqueNumber=\"1\"></xml>");
} }
[Theory] [Theory]
@@ -492,15 +492,15 @@ namespace WireMock.Net.Tests.ResponseBuilders
}; };
var request = new RequestMessage(new UrlDetails("http://localhost/foo_object"), "POST", ClientIp, bodyData); var request = new RequestMessage(new UrlDetails("http://localhost/foo_object"), "POST", ClientIp, bodyData);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBodyAsJson("test") .WithBodyAsJson("test")
.WithTransformer(transformerType); .WithTransformer(transformerType);
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(JsonConvert.SerializeObject(responseMessage.BodyData.BodyAsJson)).Equals("\"test\""); Check.That(JsonConvert.SerializeObject(response.Message.BodyData.BodyAsJson)).Equals("\"test\"");
} }
[Fact(Skip = "todo...")] [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 request = new RequestMessage(new UrlDetails("http://localhost/foo_object"), "POST", ClientIp, bodyData);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBodyAsJson("{{{request.BodyAsJson}}}") .WithBodyAsJson("{{{request.BodyAsJson}}}")
.WithTransformer(); .WithTransformer();
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // 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")] [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 request = new RequestMessage(new UrlDetails("http://localhost/foo_object"), "POST", ClientIp, bodyData);
var response = Response.Create() var responseBuilder = Response.Create()
.WithBodyAsJson("{{{request.BodyAsJson}}}") .WithBodyAsJson("{{{request.BodyAsJson}}}")
.WithTransformer(transformerType); .WithTransformer(transformerType);
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
Check.That(JsonConvert.SerializeObject(responseMessage.BodyData.BodyAsJson)).Equals("{\"name\":\"WireMock\"}"); Check.That(JsonConvert.SerializeObject(response.Message.BodyData.BodyAsJson)).Equals("{\"name\":\"WireMock\"}");
} }
[Theory] [Theory]
@@ -570,16 +570,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
}; };
var request = new RequestMessage(new UrlDetails("http://localhost/foo_object"), "POST", ClientIp, bodyData); 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) .WithBody("{{request.Body}}", BodyDestinationFormat.SameAsSource, enc)
.WithTransformer(transformerType); .WithTransformer(transformerType);
// Act // Act
var responseMessage = await response.ProvideResponseAsync(request, _settings); var response = await responseBuilder.ProvideResponseAsync(request, _settings);
// Assert // Assert
responseMessage.BodyData.BodyAsString.Should().Be(text); response.Message.BodyData.BodyAsString.Should().Be(text);
responseMessage.BodyData.Encoding.Should().Be(enc); 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