SetMaxMatchCount to exipre a rule after certain matches

Author: atwayne

src/TestServer/Rule.cs

@@ -12,28 +12,30 @@ public class Rule
         public IList<Func<HttpRequest, bool>> Predictions { get; set; }
         public Action<HttpResponse> Action { get; set; }
         public RuleSet RuleSet { get; set; }
+        public int? MaxMatchCount { get; private set; }
+        private int MatchCount { get; set; }
 
         public Rule(RuleSet ruleSet)
         {
             RuleSet = ruleSet;
             Predictions = new List<Func<HttpRequest, bool>>();
         }
 
-        public bool IsValid()
+        public bool IsActive()
         {
-            return Action != null;
+            if (Action == null)
+            {
+                return false;
+            }
+
+            return !MaxMatchCount.HasValue || MatchCount < MaxMatchCount;
         }
 
         /// <summary>
         /// Complete current Rule and add a new rule on parent RuleSet
         /// </summary>
-        /// <exception cref="InvalidOperationException">throws if current rule is not completed</exception>
         public Rule AddRule()
         {
-            if (!IsValid())
-            {
-                throw new InvalidOperationException("Previous rule not completed");
-            }
             return RuleSet.AddRule();
         }
 
@@ -128,5 +130,22 @@ public Rule SetOkResponse(string output)
             };
             return this;
         }
+
+        /// <summary>
+        /// Set how much request could apply to this rule
+        /// </summary>
+        public Rule SetMaxMatchCount(int? maxMatchCount)
+        {
+            MaxMatchCount = maxMatchCount;
+            return this;
+        }
+
+        /// <summary>
+        /// Increase the count this rule applies
+        /// </summary>
+        internal void SetMatchCount()
+        {
+            MatchCount++;
+        }
     }
 }

src/TestServer/Startup.cs

@@ -22,9 +22,15 @@ public virtual void Configure(IApplicationBuilder app, RuleSet ruleSet)
                     var matchFound = false;
                     foreach (var rule in ruleSet.Rules)
                     {
+                        if (!rule.IsActive())
+                        {
+                            continue;
+                        }
+
                         var match = rule.Predictions.All(prediction => prediction(context.Request));
                         if (match)
                         {
+                            rule.SetMatchCount();
                             await Task.Run(() =>
                             {
                                 rule.Action(context.Response);

test/TestServer.Tests/TestServerTests.cs

@@ -297,5 +297,49 @@ public async Task WhenHaveDelegatingHandler_ShouldApplyToClient()
             // Assert
             AssertOkResponse(actual);
         }
+
+        [Test]
+        public async Task WhenMaxCountReached_ShouldFail()
+        {
+            // Arrange
+            _server.CurrentRuleSet
+                .AddRule()
+                .SetMaxMatchCount(1)
+                .SetOkResponse(_okResponse);
+
+            var client = _server.CreateClient();
+
+            // Act
+            var first = await client.GetAsync("/");
+            var second = await client.GetAsync("/");
+
+            // Assert
+            AssertOkResponse(first);
+            AssertNoPredictionMatched(second);
+        }
+
+        [Test]
+        public async Task WhenFirstMatchReachedMaxCount_ShouldApplySecond()
+        {
+            // Arrange
+            var firstResponse = "first rule matched";
+            var secondResponse = "second rule matched";
+            _server.CurrentRuleSet
+                .AddRule()
+                .SetMaxMatchCount(1)
+                .SetOkResponse(firstResponse)
+                .AddRule()
+                .SetOkResponse(secondResponse);
+
+            var client = _server.CreateClient();
+
+            // Act
+            var first = await client.GetAsync("/");
+            var second = await client.GetAsync("/");
+
+            // Assert
+            AssertOkResponse(first, firstResponse);
+            AssertOkResponse(second, secondResponse);
+        }
     }
-}
+}