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

scenario and state

Browse Source
This commit is contained in:
Stef Heyenrath
2017-10-07 13:19:48 +02:00
parent ab017beaa6
commit 5424b1e2e2
10 changed files with 416 additions and 257 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -34,15 +34,23 @@ namespace WireMock
/// </value>
public int Priority { get; }
/// <summary>
/// Scenario.
/// </summary>
[CanBeNull]
public string Scenario { get; }
/// <summary>
/// Execution state condition for the current mapping.
/// </summary>
[CanBeNull]
public object ExecutionConditionState { get; }
/// <summary>
/// The next state which will be signaled after the current mapping execution.
/// In case the value is null state will not be changed.
/// </summary>
[CanBeNull]
public object NextState { get; }
/// <summary>
@@ -56,17 +64,9 @@ namespace WireMock
public IResponseProvider Provider { get; }
/// <summary>
/// Initializes a new instance of the <see cref="Mapping"/> class.
/// Is State started ?
/// </summary>
/// <param name="guid">The unique identifier.</param>
/// <param name="title">The unique title (can be null_.</param>
/// <param name="requestMatcher">The request matcher.</param>
/// <param name="provider">The provider.</param>
/// <param name="priority">The priority for this mapping.</param>
public Mapping(Guid guid, [CanBeNull] string title, IRequestMatcher requestMatcher, IResponseProvider provider, int priority)
: this(guid, title, requestMatcher, provider, priority, null, null)
{
}
public bool IsStartState => Scenario == null || Scenario != null && NextState != null && ExecutionConditionState == null;
/// <summary>
/// Initializes a new instance of the <see cref="Mapping"/> class.
@@ -76,17 +76,19 @@ namespace WireMock
/// <param name="requestMatcher">The request matcher.</param>
/// <param name="provider">The provider.</param>
/// <param name="priority">The priority for this mapping.</param>
/// <param name="executionConditionState">State in which the current mapping can occur. Happens if not null</param>
/// <param name="nextState">The next state which will occur after the current mapping execution. Happens if not null</param>
public Mapping(Guid guid, [CanBeNull] string title, IRequestMatcher requestMatcher, IResponseProvider provider, int priority, object executionConditionState, object nextState)
/// <param name="scenario">The scenario. [Optional]</param>
/// <param name="executionConditionState">State in which the current mapping can occur. [Optional]</param>
/// <param name="nextState">The next state which will occur after the current mapping execution. [Optional]</param>
public Mapping(Guid guid, [CanBeNull] string title, IRequestMatcher requestMatcher, IResponseProvider provider, int priority, [CanBeNull] string scenario, [CanBeNull] object executionConditionState, [CanBeNull] object nextState)
{
Priority = priority;
ExecutionConditionState = executionConditionState;
NextState = nextState;
Guid = guid;
Title = title;
RequestMatcher = requestMatcher;
Provider = provider;
Priority = priority;
Scenario = scenario;
ExecutionConditionState = executionConditionState;
NextState = nextState;
}
/// <summary>
@@ -100,16 +102,31 @@ namespace WireMock
}
/// <summary>
/// Determines whether the RequestMessage is handled.
/// Gets the RequestMatchResult based on the RequestMessage.
/// </summary>
/// <param name="requestMessage">The request message.</param>
/// <param name="nextState">The Next State.</param>
/// <returns>The <see cref="RequestMatchResult"/>.</returns>
public RequestMatchResult IsRequestHandled(RequestMessage requestMessage)
public RequestMatchResult GetRequestMatchResult(RequestMessage requestMessage, [CanBeNull] object nextState)
{
var result = new RequestMatchResult();
RequestMatcher.GetMatchingScore(requestMessage, result);
// Only check state if Scenario is defined
if (Scenario != null)
{
var matcher = new RequestMessageScenarioAndStateMatcher(nextState, ExecutionConditionState);
matcher.GetMatchingScore(requestMessage, result);
//// If ExecutionConditionState is null, this means that request is the start from a scenario. So just return.
//if (ExecutionConditionState != null)
//{
// // ExecutionConditionState is not null, so get score for matching with the nextState.
// var matcher = new RequestMessageScenarioAndStateMatcher(nextState, ExecutionConditionState);
// matcher.GetMatchingScore(requestMessage, result);
//}
}
return result;
}

3
src/WireMock.Net/Matchers/Request/RequestMatchResult.cs
View File

@@ -43,7 +43,7 @@ namespace WireMock.Matchers.Request
/// <summary>
/// Gets the match details.
/// </summary>
public IList<KeyValuePair<Type, double>> MatchDetails { get; private set; }
public IList<KeyValuePair<Type, double>> MatchDetails { get; }
/// <summary>
/// Initializes a new instance of the <see cref="RequestMatchResult"/> class.
@@ -72,7 +72,6 @@ namespace WireMock.Matchers.Request
/// <returns>
/// A value that indicates the relative order of the objects being compared. The return value has these meanings: Value Meaning Less than zero This instance precedes <paramref name="obj" /> in the sort order. Zero This instance occurs in the same position in the sort order as <paramref name="obj" />. Greater than zero This instance follows <paramref name="obj" /> in the sort order.
/// </returns>
/// <exception cref="System.NotImplementedException"></exception>
public int CompareTo(object obj)
{
var compareObj = (RequestMatchResult)obj;

51
src/WireMock.Net/Matchers/Request/RequestMessageScenarioAndStateMatcher.cs Normal file
View File

@@ -0,0 +1,51 @@
using JetBrains.Annotations;
namespace WireMock.Matchers.Request
{
/// <summary>
/// The scenario and state matcher.
/// </summary>
public class RequestMessageScenarioAndStateMatcher : IRequestMatcher
{
///// <summary>
///// Scenario.
///// </summary>
//[CanBeNull] private string _scenario;
/// <summary>
/// Execution state condition for the current mapping.
/// </summary>
[CanBeNull]
private readonly object _executionConditionState;
/// <summary>
/// The next state which will be signaled after the current mapping execution.
/// In case the value is null state will not be changed.
/// </summary>
[CanBeNull]
private readonly object _nextState;
/// <summary>
/// Initializes a new instance of the <see cref="RequestMessageScenarioAndStateMatcher"/> class.
/// </summary>
/// <param name="nextState">The next state.</param>
/// <param name="executionConditionState">Execution state condition for the current mapping.</param>
public RequestMessageScenarioAndStateMatcher([CanBeNull] object nextState, [CanBeNull] object executionConditionState)
{
_nextState = nextState;
_executionConditionState = executionConditionState;
}
/// <inheritdoc />
public double GetMatchingScore(RequestMessage requestMessage, RequestMatchResult requestMatchResult)
{
double score = IsMatch();
return requestMatchResult.AddScore(GetType(), score);
}
private double IsMatch()
{
return Equals(_executionConditionState, _nextState) ? MatchScores.Perfect : MatchScores.Mismatch;
}
}
}

3
src/WireMock.Net/Owin/IOwinSelfHost.cs
View File

@@ -1,5 +1,4 @@
using System;
using System.Collections.Generic;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace WireMock.Owin

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

@@ -1,9 +1,12 @@
using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading.Tasks;
using WireMock.Logging;
using WireMock.Matchers.Request;
using System.Linq;
using WireMock.Matchers;
#if !NETSTANDARD
using Microsoft.Owin;
#else
@@ -24,19 +27,17 @@ namespace WireMock.Owin
private readonly OwinRequestMapper _requestMapper = new OwinRequestMapper();
private readonly OwinResponseMapper _responseMapper = new OwinResponseMapper();
public object State { get; private set; }
private readonly IDictionary<string, object> _states = new ConcurrentDictionary<string, object>();
#if !NETSTANDARD
public WireMockMiddleware(OwinMiddleware next, WireMockMiddlewareOptions options) : base(next)
{
_options = options;
State = null;
}
#else
public WireMockMiddleware(RequestDelegate next, WireMockMiddlewareOptions options)
{
_options = options;
State = null;
}
#endif
@@ -54,12 +55,20 @@ namespace WireMock.Owin
RequestMatchResult requestMatchResult = null;
try
{
foreach (var mapping in _options.Mappings.Where(m => m.Scenario != null))
{
// Set start
if (!_states.ContainsKey(mapping.Scenario) && mapping.IsStartState)
{
_states.Add(mapping.Scenario, null);
}
}
var mappings = _options.Mappings
.Where(m => object.Equals(m.ExecutionConditionState, State))
.Select(m => new
{
Mapping = m,
MatchResult = m.IsRequestHandled(request)
MatchResult = m.GetRequestMatchResult(request, m.Scenario != null && _states.ContainsKey(m.Scenario) ? _states[m.Scenario] : null)
})
.ToList();
@@ -97,9 +106,8 @@ namespace WireMock.Owin
if (targetMapping.IsAdminInterface && _options.AuthorizationMatcher != null)
{
string authorization;
bool present = request.Headers.TryGetValue("Authorization", out authorization);
if (!present || _options.AuthorizationMatcher.IsMatch(authorization) < 1.0)
bool present = request.Headers.TryGetValue("Authorization", out var authorization);
if (!present || _options.AuthorizationMatcher.IsMatch(authorization) < MatchScores.Perfect)
{
response = new ResponseMessage { StatusCode = 401 };
return;
@@ -112,7 +120,11 @@ namespace WireMock.Owin
}
response = await targetMapping.ResponseToAsync(request);
State = targetMapping.NextState;
if (targetMapping.Scenario != null)
{
_states[targetMapping.Scenario] = targetMapping.NextState;
}
}
catch (Exception ex)
{

5
src/WireMock.Net/Server/FluentMockServer.Admin.cs
View File

@@ -69,9 +69,8 @@ namespace WireMock.Server
Check.NotNull(filename, nameof(filename));
string filenameWithoutExtension = Path.GetFileNameWithoutExtension(filename);
Guid guidFromFilename;
if (Guid.TryParse(filenameWithoutExtension, out guidFromFilename))
if (Guid.TryParse(filenameWithoutExtension, out var guidFromFilename))
{
DeserializeAndAddMapping(File.ReadAllText(filename), guidFromFilename);
}
@@ -151,7 +150,7 @@ namespace WireMock.Server
var response = (Response)Response.Create(responseMessage);
return new Mapping(Guid.NewGuid(), string.Empty, request, response, 0);
return new Mapping(Guid.NewGuid(), string.Empty, request, response, 0, null, null, null);
}
#endregion

11
src/WireMock.Net/Server/IRespondWithAProvider.cs
View File

@@ -42,14 +42,21 @@ namespace WireMock.Server
void RespondWith(IResponseProvider provider);
/// <summary>
/// Execute this respond only in case the current state is equal to specified one
/// Sets the the scenario.
/// </summary>
/// <param name="scenario">The scenario.</param>
/// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
IRespondWithAProvider InScenario(string scenario);
/// <summary>
/// Execute this respond only in case the current state is equal to specified one.
/// </summary>
/// <param name="state">Any object which identifies the current state</param>
/// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
IRespondWithAProvider WhenStateIs(object state);
/// <summary>
/// Once this mapping is executed the state will be changed to specified one
/// Once this mapping is executed the state will be changed to specified one.
/// </summary>
/// <param name="state">Any object which identifies the new state</param>
/// <returns>The <see cref="IRespondWithAProvider"/>.</returns>

56
src/WireMock.Net/Server/RespondWithAProvider.cs
View File

@@ -11,9 +11,9 @@ namespace WireMock.Server
private int _priority;
private Guid? _guid;
private string _title;
private object _executionConditionState = null;
private object _nextState = null;
private object _executionConditionState;
private object _nextState;
private string _scenario;
/// <summary>
/// The _registration callback.
@@ -45,19 +45,7 @@ namespace WireMock.Server
public void RespondWith(IResponseProvider provider)
{
var mappingGuid = _guid ?? Guid.NewGuid();
_registrationCallback(new Mapping(mappingGuid, _title, _requestMatcher, provider, _priority, _executionConditionState, _nextState));
}
public IRespondWithAProvider WhenStateIs(object state)
{
_executionConditionState = state;
return this;
}
public IRespondWithAProvider WillSetStateTo(object state)
{
_nextState = state;
return this;
_registrationCallback(new Mapping(mappingGuid, _title, _requestMatcher, provider, _priority, _scenario, _executionConditionState, _nextState));
}
/// <summary>
@@ -105,5 +93,41 @@ namespace WireMock.Server
return this;
}
public IRespondWithAProvider InScenario(string scenario)
{
_scenario = scenario;
return this;
}
public IRespondWithAProvider WhenStateIs(object state)
{
if (string.IsNullOrEmpty(_scenario))
{
throw new NotSupportedException("Unable to set state condition when no scenario is defined.");
}
//if (_nextState != null)
//{
// throw new NotSupportedException("Unable to set state condition when next state is defined.");
//}
_executionConditionState = state;
return this;
}
public IRespondWithAProvider WillSetStateTo(object state)
{
if (string.IsNullOrEmpty(_scenario))
{
throw new NotSupportedException("Unable to set next state when no scenario is defined.");
}
_nextState = state;
return this;
}
}
}

72
test/WireMock.Net.Tests/StatefulBehaviorTests.cs
View File

@@ -24,10 +24,9 @@ namespace WireMock.Net.Tests
.Given(Request.Create()
.WithPath("/foo")
.UsingGet())
.InScenario("s")
.WhenStateIs("Test state")
.RespondWith(Response.Create()
.WithStatusCode(200)
.WithBody(@"{ msg: ""Hello world!""}"));
.RespondWith(Response.Create());
// when
var response = await new HttpClient().GetAsync("http://localhost:" + _server.Ports[0] + "/foo");
@@ -37,7 +36,7 @@ namespace WireMock.Net.Tests
}
[Fact]
public async Task Should_process_request_if_equals_state()
public async Task Should_process_request_if_equals_state_and_single_state_defined()
{
// given
_server = FluentMockServer.Start();
@@ -46,19 +45,19 @@ namespace WireMock.Net.Tests
.Given(Request.Create()
.WithPath("/foo")
.UsingGet())
.InScenario("s")
.WillSetStateTo("Test state")
.RespondWith(Response.Create()
.WithStatusCode(200)
.WithBody(@"No state msg"));
.WithBody("No state msg"));
_server
.Given(Request.Create()
.WithPath("/foo")
.UsingGet())
.InScenario("s")
.WhenStateIs("Test state")
.RespondWith(Response.Create()
.WithStatusCode(200)
.WithBody(@"Test state msg"));
.WithBody("Test state msg"));
// when
var responseNoState = await new HttpClient().GetStringAsync("http://localhost:" + _server.Ports[0] + "/foo");
@@ -69,6 +68,63 @@ namespace WireMock.Net.Tests
Check.That(responseWithState).Equals("Test state msg");
}
[Fact]
public async Task Should_process_request_if_equals_state_and_multiple_state_defined()
{
// given
_server = FluentMockServer.Start();
_server
.Given(Request.Create()
.WithPath("/state1")
.UsingGet())
.InScenario("s1")
.WillSetStateTo("Test state 1")
.RespondWith(Response.Create()
.WithBody("No state msg 1"));
_server
.Given(Request.Create()
.WithPath("/foo")
.UsingGet())
.InScenario("s1")
.WhenStateIs("Test state 1")
.RespondWith(Response.Create()
.WithBody("Test state msg 1"));
_server
.Given(Request.Create()
.WithPath("/state2")
.UsingGet())
.InScenario("s2")
.WillSetStateTo("Test state 2")
.RespondWith(Response.Create()
.WithBody("No state msg 2"));
_server
.Given(Request.Create()
.WithPath("/foo")
.UsingGet())
.InScenario("s2")
.WhenStateIs("Test state 2")
.RespondWith(Response.Create()
.WithBody("Test state msg 2"));
// when
string url = "http://localhost:" + _server.Ports[0];
var responseNoState1 = await new HttpClient().GetStringAsync(url + "/state1");
var responseNoState2 = await new HttpClient().GetStringAsync(url + "/state2");
var responseWithState1 = await new HttpClient().GetStringAsync(url + "/foo");
var responseWithState2 = await new HttpClient().GetStringAsync(url + "/foo");
// then
Check.That(responseNoState1).Equals("No state msg 1");
Check.That(responseWithState1).Equals("Test state msg 1");
Check.That(responseNoState2).Equals("No state msg 2");
Check.That(responseWithState2).Equals("Test state msg 2");
}
public void Dispose()
{
_server?.Dispose();

79
test/WireMock.Net.Tests/WireMockMiddlewareTests.cs
View File

@@ -1,49 +1,44 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Owin;
using Moq;
using NFluent;
using WireMock.Owin;
using Xunit;
//using Microsoft.Owin;
//using Moq;
//using NFluent;
//using WireMock.Owin;
//using Xunit;
namespace WireMock.Net.Tests
{
public class WireMockMiddlewareTests
{
private readonly ObjectMother _objectMother = new ObjectMother();
//namespace WireMock.Net.Tests
//{
// public class WireMockMiddlewareTests
// {
// private readonly ObjectMother _objectMother = new ObjectMother();
[Fact]
public void Should_have_default_state_as_null()
{
// given
// [Fact]
// public void Should_have_default_state_as_null()
// {
// // given
// when
var sut = _objectMother.Create();
// // when
// var sut = _objectMother.Create();
// then
Check.That(sut.State).IsNull();
}
// // then
// Check.That(sut.States).IsNull();
// }
internal class ObjectMother
{
public Mock<OwinMiddleware> OwinMiddleware { get; set; }
public Mock<IOwinContext> OwinContext { get; set; }
public WireMockMiddlewareOptions WireMockMiddlewareOptions { get; set; }
// private class ObjectMother
// {
// private Mock<OwinMiddleware> OwinMiddleware { get; }
// private Mock<IOwinContext> OwinContext { get; }
// private WireMockMiddlewareOptions WireMockMiddlewareOptions { get; }
public ObjectMother()
{
OwinContext = new Mock<IOwinContext>();
OwinMiddleware = new Mock<OwinMiddleware>(null);
WireMockMiddlewareOptions = new WireMockMiddlewareOptions();
}
// public ObjectMother()
// {
// OwinContext = new Mock<IOwinContext>();
// OwinMiddleware = new Mock<OwinMiddleware>(null);
// WireMockMiddlewareOptions = new WireMockMiddlewareOptions();
// }
public WireMockMiddleware Create()
{
return new WireMockMiddleware(OwinMiddleware.Object, WireMockMiddlewareOptions);
}
}
}
}
// public WireMockMiddleware Create()
// {
// return new WireMockMiddleware(OwinMiddleware.Object, WireMockMiddlewareOptions);
// }
// }
// }
//}