stateful behavior + tests

src/WireMock.Net/Mapping.cs

@@ -34,6 +34,17 @@ namespace WireMock
         /// </value>
         public int Priority { get; }
 
+        /// <summary>
+        /// Execution state condition for the current mapping.
+        /// </summary>
+        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>
+        public object NextState { get; }
+
         /// <summary>
         /// The Request matcher.
         /// </summary>
@@ -53,8 +64,25 @@ namespace WireMock
         /// <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)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Mapping"/> class.
+        /// </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>
+        /// <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)
         {
             Priority = priority;
+            ExecutionConditionState = executionConditionState;
+            NextState = nextState;
             Guid = guid;
             Title = title;
             RequestMatcher = requestMatcher;

src/WireMock.Net/Owin/WireMockMiddleware.cs

@@ -24,15 +24,19 @@ namespace WireMock.Owin
         private readonly OwinRequestMapper _requestMapper = new OwinRequestMapper();
         private readonly OwinResponseMapper _responseMapper = new OwinResponseMapper();
 
+        public object State { get; private set; }
+
 #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
 
@@ -51,6 +55,7 @@ namespace WireMock.Owin
             try
             {
                 var mappings = _options.Mappings
+                    .Where(m => object.Equals(m.ExecutionConditionState, State))
                     .Select(m => new
                     {
                         Mapping = m,
@@ -107,6 +112,7 @@ namespace WireMock.Owin
                 }
 
                 response = await targetMapping.ResponseToAsync(request);
+                State = targetMapping.NextState;
             }
             catch (Exception ex)
             {

src/WireMock.Net/Properties/AssemblyInfo.cs

@@ -1,3 +1,4 @@
 using System.Runtime.CompilerServices;
 
-[assembly: InternalsVisibleTo("WireMock.Net.StandAlone")]
+[assembly: InternalsVisibleTo("WireMock.Net.StandAlone")]
+[assembly: InternalsVisibleTo("WireMock.Net.Tests")]

src/WireMock.Net/Server/IRespondWithAProvider.cs

@@ -40,5 +40,19 @@ namespace WireMock.Server
         /// </summary>
         /// <param name="provider">The provider.</param>
         void RespondWith(IResponseProvider provider);
+
+        /// <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
+        /// </summary>
+        /// <param name="state">Any object which identifies the new state</param>
+        /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
+        IRespondWithAProvider WillSetStateTo(object state);
     }
 }

src/WireMock.Net/Server/RespondWithAProvider.cs

@@ -12,6 +12,9 @@ namespace WireMock.Server
         private Guid? _guid;
         private string _title;
 
+        private object _executionConditionState = null;
+        private object _nextState = null;
+
         /// <summary>
         /// The _registration callback.
         /// </summary>
@@ -42,7 +45,19 @@ namespace WireMock.Server
         public void RespondWith(IResponseProvider provider)
         {
             var mappingGuid = _guid ?? Guid.NewGuid();
-            _registrationCallback(new Mapping(mappingGuid, _title, _requestMatcher, provider, _priority));
+            _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;
         }
 
         /// <summary>