Add blacklist for Request Cookies. (#319)

* Add blacklist for Request Cookies.
Refactor code. Fix tests.

* Fix tests and address code review notes

* Fix tests

src/WireMock.Net.StandAlone/StandAloneApp.cs

@@ -81,7 +81,8 @@ namespace WireMock.Net.StandAlone
                     SaveMapping = parser.GetBoolValue("SaveMapping"),
                     SaveMappingToFile = parser.GetBoolValue("SaveMappingToFile"),
                     ClientX509Certificate2ThumbprintOrSubjectName = parser.GetStringValue("ClientX509Certificate2ThumbprintOrSubjectName"),
-                    BlackListedHeaders = parser.GetValues("BlackListedHeaders")
+                    BlackListedHeaders = parser.GetValues("BlackListedHeaders"),
+                    BlackListedCookies = parser.GetValues("BlackListedCookies")
                 };
             }
 

src/WireMock.Net/Server/FluentMockServer.Admin.cs

@@ -268,7 +268,7 @@ namespace WireMock.Server
 
             if (settings.ProxyAndRecordSettings.SaveMapping || settings.ProxyAndRecordSettings.SaveMappingToFile)
             {
-                var mapping = ToMapping(requestMessage, responseMessage, settings.ProxyAndRecordSettings.BlackListedHeaders ?? new string[] { });
+                var mapping = ToMapping(requestMessage, responseMessage, settings.ProxyAndRecordSettings.BlackListedHeaders ?? new string[] { }, settings.ProxyAndRecordSettings.BlackListedCookies ?? new string[] { });
 
                 if (settings.ProxyAndRecordSettings.SaveMapping)
                 {
@@ -284,19 +284,25 @@ namespace WireMock.Server
             return responseMessage;
         }
 
-        private IMapping ToMapping(RequestMessage requestMessage, ResponseMessage responseMessage, string[] blacklistedHeaders)
+        private IMapping ToMapping(RequestMessage requestMessage, ResponseMessage responseMessage, string[] blacklistedHeaders, string[] blacklistedCookies)
         {
             var request = Request.Create();
             request.WithPath(requestMessage.Path);
             request.UsingMethod(requestMessage.Method);
 
             requestMessage.Query.Loop((key, value) => request.WithParam(key, false, value.ToArray()));
-            requestMessage.Cookies.Loop((key, value) => request.WithCookie(key, value));
+            requestMessage.Cookies.Loop((key, value) =>
+            {
+                if (!blacklistedCookies.Contains(key, StringComparer.OrdinalIgnoreCase))
+                {
+                    request.WithCookie(key, value);
+                }
+            });
 
             var allBlackListedHeaders = new List<string>(blacklistedHeaders) { "Cookie" };
             requestMessage.Headers.Loop((key, value) =>
             {
-                if (!allBlackListedHeaders.Any(b => string.Equals(key, b, StringComparison.OrdinalIgnoreCase)))
+                if (!allBlackListedHeaders.Contains(key, StringComparer.OrdinalIgnoreCase))
                 {
                     request.WithHeader(key, value.ToArray());
                 }

src/WireMock.Net/Settings/IProxyAndRecordSettings.cs

@@ -30,5 +30,10 @@
         /// Defines a list from headers which will excluded from the saved mappings.
         /// </summary>
         string[] BlackListedHeaders { get; set; }
+
+        /// <summary>
+        /// Defines a list of cookies which will excluded from the saved mappings.
+        /// </summary>
+        string[] BlackListedCookies { get; set; }
     }
 }

src/WireMock.Net/Settings/ProxyAndRecordSettings.cs

@@ -26,5 +26,9 @@ namespace WireMock.Settings
         /// <inheritdoc cref="IProxyAndRecordSettings.BlackListedHeaders"/>
         [PublicAPI]
         public string[] BlackListedHeaders { get; set; }
+
+        /// <inheritdoc cref="IProxyAndRecordSettings.BlackListedCookies"/>
+        [PublicAPI]
+        public string[] BlackListedCookies { get; set; }
     }
 }

test/WireMock.Net.Tests/FluentMockServerTests.Proxy.cs

@@ -6,6 +6,7 @@ using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Text;
 using System.Threading.Tasks;
+using WireMock.Matchers.Request;
 using WireMock.RequestBuilders;
 using WireMock.ResponseBuilders;
 using WireMock.Server;
@@ -109,6 +110,7 @@ namespace WireMock.Net.Tests
                 }
             };
             var server = FluentMockServer.Start(settings);
+            var defaultMapping = server.Mappings.First();
 
             // Act
             var requestMessage = new HttpRequestMessage
@@ -117,18 +119,65 @@ namespace WireMock.Net.Tests
                 RequestUri = new Uri($"{server.Urls[0]}{path}"),
                 Content = new StringContent("stringContent")
             };
-            requestMessage.Headers.Add("blacklisted", "test");
+            requestMessage.Headers.Add("blacklisted", "exact_match");
             requestMessage.Headers.Add("ok", "ok-value");
             await new HttpClient().SendAsync(requestMessage);
 
             // Assert
-            var receivedRequest = serverForProxyForwarding.LogEntries.First().RequestMessage;
+            var mapping = server.Mappings.FirstOrDefault(m => m.Guid != defaultMapping.Guid);
-            Check.That(receivedRequest.Headers).Not.ContainsKey("bbb");
+            Check.That(mapping).IsNotNull();
-            Check.That(receivedRequest.Headers).ContainsKey("ok");
+            var matchers = ((Request)mapping.RequestMatcher).GetRequestMessageMatchers<RequestMessageHeaderMatcher>().Select(m => m.Name).ToList();
+            Check.That(matchers).Not.Contains("blacklisted");
+            Check.That(matchers).Contains("ok");
+        }        
+        
+        [Fact]
+        public async Task FluentMockServer_Proxy_Should_exclude_blacklisted_cookies_in_mapping()
+        {
+            // Assign
+            string path = $"/prx_{Guid.NewGuid().ToString()}";
+            var serverForProxyForwarding = FluentMockServer.Start();
+            serverForProxyForwarding
+                .Given(Request.Create().WithPath(path))
+                .RespondWith(Response.Create());
 
-            //var mapping = _server.Mappings.Last();
+            var settings = new FluentMockServerSettings
-            //var matcher = ((Request)mapping.RequestMatcher).GetRequestMessageMatchers<RequestMessageHeaderMatcher>().FirstOrDefault(m => m.Name == "bbb");
+            {
-            //Check.That(matcher).IsNull();
+                ProxyAndRecordSettings = new ProxyAndRecordSettings
+                {
+                    Url = serverForProxyForwarding.Urls[0],
+                    SaveMapping = true,
+                    SaveMappingToFile = false,
+                    BlackListedCookies = new[] { "ASP.NET_SessionId" }
+                }
+            };
+            var server = FluentMockServer.Start(settings);
+            var defaultMapping = server.Mappings.First();
+
+            // Act
+            var requestMessage = new HttpRequestMessage
+            {
+                Method = HttpMethod.Post,
+                RequestUri = new Uri($"{server.Urls[0]}{path}"),
+                Content = new StringContent("stringContent")
+            };
+
+            var cookieContainer = new CookieContainer(3);
+            cookieContainer.Add(new Uri("http://localhost"), new Cookie("ASP.NET_SessionId", "exact_match"));
+            cookieContainer.Add(new Uri("http://localhost"), new Cookie("AsP.NeT_SessIonID", "case_mismatch"));
+            cookieContainer.Add(new Uri("http://localhost"), new Cookie("GoodCookie", "I_should_pass"));
+            
+            var handler = new HttpClientHandler { CookieContainer = cookieContainer };
+            await new HttpClient(handler).SendAsync(requestMessage);
+
+            // Assert
+            var mapping = server.Mappings.FirstOrDefault(m => m.Guid != defaultMapping.Guid);
+            Check.That(mapping).IsNotNull();
+
+            var matchers = ((Request)mapping.RequestMatcher).GetRequestMessageMatchers<RequestMessageCookieMatcher>().Select(m => m.Name).ToList();
+            Check.That(matchers).Not.Contains("ASP.NET_SessionId");
+            Check.That(matchers).Not.Contains("AsP.NeT_SessIonID");
+            Check.That(matchers).Contains("GoodCookie");
         }
 
         [Fact]