Summary

Class:	WireMock.Server.FluentMockServer
Assembly:	WireMock.Net
File(s):	C:\Users\azureuser\Documents\Github\WireMock.Net\src\WireMock.Net\Server\FluentMockServer.Admin.cs C:\Users\azureuser\Documents\Github\WireMock.Net\src\WireMock.Net\Server\FluentMockServer.cs C:\Users\azureuser\Documents\Github\WireMock.Net\src\WireMock.Net\Server\FluentMockServer.LogEntries.cs
Covered lines:	393
Uncovered lines:	328
Coverable lines:	721
Total lines:	1265
Line coverage:	54.5%
Branch coverage:	49.4%

Metrics

Method	Cyclomatic complexity	NPath complexity	Sequence coverage	Branch coverage
InitAdmin()	1	0	100	100
ReadStaticMappings(...)	6	4	70.59	60
WatchStaticMappings(...)	3	4	0	0
ReadStaticMappingAndAddOrUpdate(...)	2	2	100	100
InitProxyAndRecord(...)	1	0	100	100
ToMapping(...)	2	2	100	66.67
SettingsGet(...)	5	0	0	0
SettingsUpdate(...)	4	4	0	0
MappingGet(...)	2	2	0	0
MappingPut(...)	2	0	0	0
MappingDelete(...)	2	2	0	0
MappingsSave(...)	4	0	0	0
SaveMappingToFile(...)	3	2	0	0
SanitizeFileName(...)	1	0	0	0
MappingsGet(...)	4	0	0	0
MappingsPost(...)	2	0	46.67	100
DeserializeAndAddOrUpdateMapping(...)	12	256	85.71	76.47
MappingsDelete(...)	1	0	0	0
RequestGet(...)	2	2	0	0
RequestDelete(...)	2	2	0	0
RequestsGet(...)	2	0	100	100
ToLogEntryModel(...)	8	8	100	57.14
RequestsDelete(...)	1	0	0	0
RequestsFind(...)	8	2	100	66.67
ScenariosGet(...)	2	0	0	0
ScenariosReset(...)	1	0	0	0
InitRequestBuilder(...)	32	262144	37.5	48.65
InitResponseBuilder(...)	18	4096	44.26	44
ToJson(...)	1	0	100	100
ToEncoding(...)	3	2	100	100
.ctor(...)	27	131072	72.22	62.86
.cctor()	1	0	100	100
ProxyAndRecordAsync()	6	8	86.67	71.43
Start(...)	1	0	100	100
Start(...)	1	0	100	100
Start(...)	1	0	100	100
StartWithAdminInterface(...)	1	0	100	100
StartWithAdminInterface(...)	1	0	0	0
StartWithAdminInterfaceAndReadStaticMappings(...)	1	0	0	0
Stop()	2	2	100	66.67
AddCatchAllMapping()	2	0	0	0
Dispose()	3	2	100	66.67
Reset()	1	0	0	0
ResetMappings()	4	0	100	100
DeleteMapping(...)	2	2	0	0
DeleteMapping(...)	1	0	0	0
AddGlobalProcessingDelay(...)	1	0	100	100
AllowPartialMapping(...)	1	0	0	0
SetBasicAuthentication(...)	1	0	0	0
RemoveBasicAuthentication()	1	0	0	0
SetMaxRequestLogCount(...)	1	0	100	100
SetRequestLogExpirationDuration(...)	1	0	0	0
ResetScenarios()	1	0	0	0
Given(...)	1	0	100	100
RegisterMapping(...)	2	2	100	100
add_LogEntriesChanged(...)	1	0	100	100
remove_LogEntriesChanged(...)	1	0	0	0
FindLogEntries(...)	7	2	100	100
ResetLogEntries()	1	0	100	100
DeleteLogEntry(...)	2	2	0	0

File(s)

C:\Users\azureuser\Documents\Github\WireMock.Net\src\WireMock.Net\Server\FluentMockServer.Admin.cs

	#	Line		Line coverage
		1		using System;
		2		using System.Collections.Generic;
		3		using System.IO;
		4		using System.Linq;
		5		using System.Net.Http;
		6		using System.Text;
		7		using System.Threading.Tasks;
		8		using JetBrains.Annotations;
		9		using Newtonsoft.Json;
		10		using Newtonsoft.Json.Linq;
		11		using WireMock.Admin.Mappings;
		12		using WireMock.Admin.Requests;
		13		using WireMock.Admin.Settings;
		14		using WireMock.Http;
		15		using WireMock.Logging;
		16		using WireMock.Matchers;
		17		using WireMock.Matchers.Request;
		18		using WireMock.RequestBuilders;
		19		using WireMock.ResponseBuilders;
		20		using WireMock.ResponseProviders;
		21		using WireMock.Serialization;
		22		using WireMock.Settings;
		23		using WireMock.Util;
		24		using WireMock.Validation;
		25
		26		namespace WireMock.Server
		27		{
		28		/// <summary>
		29		/// The fluent mock server.
		30		/// </summary>
		31		public partial class FluentMockServer
		32		{
	1	33		private static readonly string AdminMappingsFolder = Path.Combine("__admin", "mappings");
		34		private const string ContentTypeJson = "application/json";
		35		private const string AdminMappings = "/__admin/mappings";
		36		private const string AdminRequests = "/__admin/requests";
		37		private const string AdminSettings = "/__admin/settings";
		38		private const string AdminScenarios = "/__admin/scenarios";
	47	39		private readonly RegexMatcher _adminMappingsGuidPathMatcher = new RegexMatcher(@"^\/__admin\/mappings\/(\{{0,1}(
	47	40		private readonly RegexMatcher _adminRequestsGuidPathMatcher = new RegexMatcher(@"^\/__admin\/requests\/(\{{0,1}(
		41
	47	42		private readonly JsonSerializerSettings _settings = new JsonSerializerSettings
	47	43		{
	47	44		Formatting = Formatting.Indented,
	47	45		NullValueHandling = NullValueHandling.Ignore,
	47	46		};
		47
		48		#region InitAdmin
		49		private void InitAdmin()
	3	50		{
		51		// __admin/settings
	3	52		Given(Request.Create().WithPath(AdminSettings).UsingGet()).RespondWith(new DynamicResponseProvider(SettingsG
	3	53		Given(Request.Create().WithPath(AdminSettings).UsingVerb("PUT", "POST").WithHeader(HttpKnownHeaderNames.Cont
		54
		55
		56		// __admin/mappings
	3	57		Given(Request.Create().WithPath(AdminMappings).UsingGet()).RespondWith(new DynamicResponseProvider(MappingsG
	3	58		Given(Request.Create().WithPath(AdminMappings).UsingPost().WithHeader(HttpKnownHeaderNames.ContentType, Cont
	3	59		Given(Request.Create().WithPath(AdminMappings).UsingDelete()).RespondWith(new DynamicResponseProvider(Mappin
		60
		61		// __admin/mappings/reset
	3	62		Given(Request.Create().WithPath(AdminMappings + "/reset").UsingPost()).RespondWith(new DynamicResponseProvid
		63
		64		// __admin/mappings/{guid}
	3	65		Given(Request.Create().WithPath(_adminMappingsGuidPathMatcher).UsingGet()).RespondWith(new DynamicResponsePr
	3	66		Given(Request.Create().WithPath(_adminMappingsGuidPathMatcher).UsingPut().WithHeader(HttpKnownHeaderNames.Co
	3	67		Given(Request.Create().WithPath(_adminMappingsGuidPathMatcher).UsingDelete()).RespondWith(new DynamicRespons
		68
		69		// __admin/mappings/save
	3	70		Given(Request.Create().WithPath(AdminMappings + "/save").UsingPost()).RespondWith(new DynamicResponseProvide
		71
		72
		73		// __admin/requests
	3	74		Given(Request.Create().WithPath(AdminRequests).UsingGet()).RespondWith(new DynamicResponseProvider(RequestsG
	3	75		Given(Request.Create().WithPath(AdminRequests).UsingDelete()).RespondWith(new DynamicResponseProvider(Reques
		76
		77		// __admin/requests/reset
	3	78		Given(Request.Create().WithPath(AdminRequests + "/reset").UsingPost()).RespondWith(new DynamicResponseProvid
		79
		80		// __admin/request/{guid}
	3	81		Given(Request.Create().WithPath(_adminRequestsGuidPathMatcher).UsingGet()).RespondWith(new DynamicResponsePr
	3	82		Given(Request.Create().WithPath(_adminRequestsGuidPathMatcher).UsingDelete()).RespondWith(new DynamicRespons
		83
		84		// __admin/requests/find
	3	85		Given(Request.Create().WithPath(AdminRequests + "/find").UsingPost()).RespondWith(new DynamicResponseProvide
		86
		87
		88		// __admin/scenarios
	3	89		Given(Request.Create().WithPath(AdminScenarios).UsingGet()).RespondWith(new DynamicResponseProvider(Scenario
	3	90		Given(Request.Create().WithPath(AdminScenarios).UsingDelete()).RespondWith(new DynamicResponseProvider(Scena
		91
		92		// __admin/scenarios/reset
	3	93		Given(Request.Create().WithPath(AdminScenarios + "/reset").UsingPost()).RespondWith(new DynamicResponseProvi
	3	94		}
		95		#endregion
		96
		97		#region StaticMappings
		98		/// <summary>
		99		/// Reads the static mappings from a folder.
		100		/// </summary>
		101		/// <param name="folder">The optional folder. If not defined, use \__admin\mappings\</param>
		102		[PublicAPI]
		103		public void ReadStaticMappings([CanBeNull] string folder = null)
	1	104		{
	1	105		if (folder == null)
	0	106		{
	0	107		folder = Path.Combine(Directory.GetCurrentDirectory(), AdminMappingsFolder);
	0	108		}
		109
	1	110		if (!Directory.Exists(folder))
	0	111		{
	0	112		return;
		113		}
		114
	9	115		foreach (string filename in Directory.EnumerateFiles(folder).OrderBy(f => f))
	2	116		{
	2	117		_logger.Info("Reading Static MappingFile : '{0}'", filename);
	2	118		ReadStaticMappingAndAddOrUpdate(filename);
	2	119		}
	1	120		}
		121
		122		/// <summary>
		123		/// Watches the static mappings for changes.
		124		/// </summary>
		125		/// <param name="folder">The optional folder. If not defined, use \__admin\mappings\</param>
		126		[PublicAPI]
		127		public void WatchStaticMappings([CanBeNull] string folder = null)
	0	128		{
	0	129		if (folder == null)
	0	130		{
	0	131		folder = Path.Combine(Directory.GetCurrentDirectory(), AdminMappingsFolder);
	0	132		}
		133
	0	134		if (!Directory.Exists(folder))
	0	135		{
	0	136		return;
		137		}
		138
	0	139		_logger.Info("Watching folder '{0}' for new, updated and deleted MappingFiles.", folder);
		140
	0	141		var watcher = new EnhancedFileSystemWatcher(folder, "*.json", 1000);
	0	142		watcher.Created += (sender, args) =>
	0	143		{
	0	144		_logger.Info("New MappingFile created : '{0}'", args.FullPath);
	0	145		ReadStaticMappingAndAddOrUpdate(args.FullPath);
	0	146		};
	0	147		watcher.Changed += (sender, args) =>
	0	148		{
	0	149		_logger.Info("New MappingFile updated : '{0}'", args.FullPath);
	0	150		ReadStaticMappingAndAddOrUpdate(args.FullPath);
	0	151		};
	0	152		watcher.Deleted += (sender, args) =>
	0	153		{
	0	154		_logger.Info("New MappingFile deleted : '{0}'", args.FullPath);
	0	155		string filenameWithoutExtension = Path.GetFileNameWithoutExtension(args.FullPath);
	0	156
	0	157		if (Guid.TryParse(filenameWithoutExtension, out Guid guidFromFilename))
	0	158		{
	0	159		DeleteMapping(guidFromFilename);
	0	160		}
	0	161		else
	0	162		{
	0	163		DeleteMapping(args.FullPath);
	0	164		}
	0	165		};
		166
	0	167		watcher.EnableRaisingEvents = true;
	0	168		}
		169
		170		/// <summary>
		171		/// Reads a static mapping file and adds or updates the mapping.
		172		/// </summary>
		173		/// <param name="path">The path.</param>
		174		[PublicAPI]
		175		public void ReadStaticMappingAndAddOrUpdate([NotNull] string path)
	4	176		{
	4	177		Check.NotNull(path, nameof(path));
		178
	4	179		string filenameWithoutExtension = Path.GetFileNameWithoutExtension(path);
		180
	4	181		MappingModel mappingModel = JsonConvert.DeserializeObject<MappingModel>(FileHelper.ReadAllText(path));
	4	182		if (Guid.TryParse(filenameWithoutExtension, out Guid guidFromFilename))
	2	183		{
	2	184		DeserializeAndAddOrUpdateMapping(mappingModel, guidFromFilename, path);
	2	185		}
		186		else
	2	187		{
	2	188		DeserializeAndAddOrUpdateMapping(mappingModel, null, path);
	2	189		}
	4	190		}
		191		#endregion
		192
		193		#region Proxy and Record
		194		private HttpClient _httpClientForProxy;
		195
		196		private void InitProxyAndRecord(IProxyAndRecordSettings settings)
	2	197		{
	2	198		_httpClientForProxy = HttpClientHelper.CreateHttpClient(settings.ClientX509Certificate2ThumbprintOrSubjectNa
	2	199		Given(Request.Create().WithPath("/*").UsingAnyVerb()).RespondWith(new ProxyAsyncResponseProvider(ProxyAndRec
	2	200		}
		201
		202		private async Task<ResponseMessage> ProxyAndRecordAsync(RequestMessage requestMessage, IProxyAndRecordSettings s
	2	203		{
	2	204		var requestUri = new Uri(requestMessage.Url);
	2	205		var proxyUri = new Uri(settings.Url);
	2	206		var proxyUriWithRequestPathAndQuery = new Uri(proxyUri, requestUri.PathAndQuery);
		207
	2	208		var responseMessage = await HttpClientHelper.SendAsync(_httpClientForProxy, requestMessage, proxyUriWithRequ
		209
	2	210		if (settings.SaveMapping)
	2	211		{
	2	212		var mapping = ToMapping(requestMessage, responseMessage, settings.BlackListedHeaders ?? new string[] { }
	2	213		_options.Mappings.Add(mapping.Guid, mapping);
		214
	2	215		if (settings.SaveMappingToFile)
	0	216		{
	0	217		SaveMappingToFile(mapping);
	0	218		}
	2	219		}
		220
	2	221		return responseMessage;
	2	222		}
		223
		224		private Mapping ToMapping(RequestMessage requestMessage, ResponseMessage responseMessage, string[] blacklistedHe
	2	225		{
	2	226		var request = Request.Create();
	2	227		request.WithPath(requestMessage.Path);
	2	228		request.UsingVerb(requestMessage.Method);
		229
	2	230		requestMessage.Query.Loop((key, value) => request.WithParam(key, value.ToArray()));
	2	231		requestMessage.Cookies.Loop((key, value) => request.WithCookie(key, value));
		232
	2	233		var allBlackListedHeaders = new List<string>(blacklistedHeaders) { "Cookie" };
	2	234		requestMessage.Headers.Loop((key, value) =>
	15	235		{
	34	236		if (!allBlackListedHeaders.Any(b => string.Equals(key, b, StringComparison.OrdinalIgnoreCase)))
	14	237		{
	14	238		request.WithHeader(key, value.ToArray());
	14	239		}
	15	240		});
		241
	2	242		if (requestMessage.Body != null)
	2	243		{
	2	244		request.WithBody(new ExactMatcher(requestMessage.Body));
	2	245		}
		246
	2	247		var response = Response.Create(responseMessage);
		248
	2	249		return new Mapping(Guid.NewGuid(), string.Empty, null, request, response, 0, null, null, null);
	2	250		}
		251		#endregion
		252
		253		#region Settings
		254		private ResponseMessage SettingsGet(RequestMessage requestMessage)
	0	255		{
	0	256		var model = new SettingsModel
	0	257		{
	0	258		AllowPartialMapping = _options.AllowPartialMapping,
	0	259		MaxRequestLogCount = _options.MaxRequestLogCount,
	0	260		RequestLogExpirationDuration = _options.RequestLogExpirationDuration,
	0	261		GlobalProcessingDelay = (int?)_options.RequestProcessingDelay?.TotalMilliseconds
	0	262		};
		263
	0	264		return ToJson(model);
	0	265		}
		266
		267		private ResponseMessage SettingsUpdate(RequestMessage requestMessage)
	0	268		{
	0	269		var settings = requestMessage.Body != null ? JsonConvert.DeserializeObject<SettingsModel>(requestMessage.Bod
		270
	0	271		if (settings.AllowPartialMapping != null)
	0	272		_options.AllowPartialMapping = settings.AllowPartialMapping.Value;
		273
	0	274		_options.MaxRequestLogCount = settings.MaxRequestLogCount;
		275
	0	276		_options.RequestLogExpirationDuration = settings.RequestLogExpirationDuration;
		277
	0	278		if (settings.GlobalProcessingDelay != null)
	0	279		_options.RequestProcessingDelay = TimeSpan.FromMilliseconds(settings.GlobalProcessingDelay.Value);
		280
	0	281		return new ResponseMessage { Body = "Settings updated" };
	0	282		}
		283		#endregion Settings
		284
		285		#region Mapping/{guid}
		286		private ResponseMessage MappingGet(RequestMessage requestMessage)
	0	287		{
	0	288		Guid guid = Guid.Parse(requestMessage.Path.Substring(AdminMappings.Length + 1));
	0	289		var mapping = Mappings.FirstOrDefault(m => !m.IsAdminInterface && m.Guid == guid);
		290
	0	291		if (mapping == null)
	0	292		{
	0	293		_logger.Warn("HttpStatusCode set to 404 : Mapping not found");
	0	294		return new ResponseMessage { StatusCode = 404, Body = "Mapping not found" };
		295		}
		296
	0	297		var model = MappingConverter.ToMappingModel(mapping);
		298
	0	299		return ToJson(model);
	0	300		}
		301
		302		private ResponseMessage MappingPut(RequestMessage requestMessage)
	0	303		{
	0	304		Guid guid = Guid.Parse(requestMessage.Path.TrimStart(AdminMappings.ToCharArray()));
		305
	0	306		MappingModel mappingModel = requestMessage.Body != null ? JsonConvert.DeserializeObject<MappingModel>(reques
	0	307		DeserializeAndAddOrUpdateMapping(mappingModel, guid);
		308
	0	309		return new ResponseMessage { Body = "Mapping added or updated" };
	0	310		}
		311
		312		private ResponseMessage MappingDelete(RequestMessage requestMessage)
	0	313		{
	0	314		Guid guid = Guid.Parse(requestMessage.Path.Substring(AdminMappings.Length + 1));
		315
	0	316		if (DeleteMapping(guid))
	0	317		{
	0	318		return new ResponseMessage { Body = "Mapping removed" };
		319		}
		320
	0	321		return new ResponseMessage { Body = "Mapping not found" };
	0	322		}
		323		#endregion Mapping/{guid}
		324
		325		#region Mappings
		326		private ResponseMessage MappingsSave(RequestMessage requestMessage)
	0	327		{
	0	328		foreach (var mapping in Mappings.Where(m => !m.IsAdminInterface))
	0	329		{
	0	330		SaveMappingToFile(mapping);
	0	331		}
		332
	0	333		return new ResponseMessage { Body = "Mappings saved to disk" };
	0	334		}
		335
		336		private void SaveMappingToFile(Mapping mapping)
	0	337		{
	0	338		string folder = Path.Combine(Directory.GetCurrentDirectory(), AdminMappingsFolder);
	0	339		if (!Directory.Exists(folder))
	0	340		{
	0	341		Directory.CreateDirectory(folder);
	0	342		}
		343
	0	344		var model = MappingConverter.ToMappingModel(mapping);
	0	345		string filename = !string.IsNullOrEmpty(mapping.Title) ? SanitizeFileName(mapping.Title) : mapping.Guid.ToSt
		346
	0	347		string filePath = Path.Combine(folder, filename + ".json");
	0	348		_logger.Info("Saving Mapping to file {0}", filePath);
		349
	0	350		File.WriteAllText(filePath, JsonConvert.SerializeObject(model, _settings));
	0	351		}
		352
		353		private static string SanitizeFileName(string name, char replaceChar = '_')
	0	354		{
	0	355		return Path.GetInvalidFileNameChars().Aggregate(name, (current, c) => current.Replace(c, replaceChar));
	0	356		}
		357
		358		private ResponseMessage MappingsGet(RequestMessage requestMessage)
	0	359		{
	0	360		var result = new List<MappingModel>();
	0	361		foreach (var mapping in Mappings.Where(m => !m.IsAdminInterface))
	0	362		{
	0	363		var model = MappingConverter.ToMappingModel(mapping);
	0	364		result.Add(model);
	0	365		}
		366
	0	367		return ToJson(result);
	0	368		}
		369
		370		private ResponseMessage MappingsPost(RequestMessage requestMessage)
	1	371		{
		372		try
	1	373		{
	1	374		MappingModel mappingModel = requestMessage.Body != null ? JsonConvert.DeserializeObject<MappingModel>(re
	1	375		DeserializeAndAddOrUpdateMapping(mappingModel);
	1	376		}
	0	377		catch (ArgumentException a)
	0	378		{
	0	379		_logger.Error("HttpStatusCode set to 400 {0}", a);
	0	380		return new ResponseMessage { StatusCode = 400, Body = a.Message };
		381		}
	0	382		catch (Exception e)
	0	383		{
	0	384		_logger.Error("HttpStatusCode set to 500 {0}", e);
	0	385		return new ResponseMessage { StatusCode = 500, Body = e.ToString() };
		386		}
		387
	1	388		return new ResponseMessage { StatusCode = 201, Body = "Mapping added" };
	1	389		}
		390
		391		private void DeserializeAndAddOrUpdateMapping(MappingModel mappingModel, Guid? guid = null, string path = null)
	5	392		{
	5	393		Check.NotNull(mappingModel, nameof(mappingModel));
	5	394		Check.NotNull(mappingModel.Request, nameof(mappingModel.Request));
	5	395		Check.NotNull(mappingModel.Response, nameof(mappingModel.Response));
		396
	5	397		var requestBuilder = InitRequestBuilder(mappingModel.Request);
	5	398		var responseBuilder = InitResponseBuilder(mappingModel.Response);
		399
	5	400		IRespondWithAProvider respondProvider = Given(requestBuilder);
		401
	5	402		if (guid != null)
	2	403		{
	2	404		respondProvider = respondProvider.WithGuid(guid.Value);
	2	405		}
	3	406		else if (mappingModel.Guid != null && mappingModel.Guid != Guid.Empty)
	2	407		{
	2	408		respondProvider = respondProvider.WithGuid(mappingModel.Guid.Value);
	2	409		}
		410
	5	411		if (path != null)
	4	412		{
	4	413		respondProvider = respondProvider.WithPath(path);
	4	414		}
		415
	5	416		if (!string.IsNullOrEmpty(mappingModel.Title))
	3	417		{
	3	418		respondProvider = respondProvider.WithTitle(mappingModel.Title);
	3	419		}
		420
	5	421		if (mappingModel.Priority != null)
	5	422		{
	5	423		respondProvider = respondProvider.AtPriority(mappingModel.Priority.Value);
	5	424		}
		425
	5	426		if (mappingModel.Scenario != null)
	0	427		{
	0	428		respondProvider = respondProvider.InScenario(mappingModel.Scenario);
	0	429		respondProvider = respondProvider.WhenStateIs(mappingModel.WhenStateIs);
	0	430		respondProvider = respondProvider.WillSetStateTo(mappingModel.SetStateTo);
	0	431		}
		432
	5	433		respondProvider.RespondWith(responseBuilder);
	5	434		}
		435
		436		private ResponseMessage MappingsDelete(RequestMessage requestMessage)
	0	437		{
	0	438		ResetMappings();
		439
	0	440		ResetScenarios();
		441
	0	442		return new ResponseMessage { Body = "Mappings deleted" };
	0	443		}
		444		#endregion Mappings
		445
		446		#region Request/{guid}
		447		private ResponseMessage RequestGet(RequestMessage requestMessage)
	0	448		{
	0	449		Guid guid = Guid.Parse(requestMessage.Path.Substring(AdminRequests.Length + 1));
	0	450		var entry = LogEntries.FirstOrDefault(r => !r.RequestMessage.Path.StartsWith("/__admin/") && r.Guid == guid)
		451
	0	452		if (entry == null)
	0	453		{
	0	454		_logger.Warn("HttpStatusCode set to 404 : Request not found");
	0	455		return new ResponseMessage { StatusCode = 404, Body = "Request not found" };
		456		}
		457
	0	458		var model = ToLogEntryModel(entry);
		459
	0	460		return ToJson(model);
	0	461		}
		462
		463		private ResponseMessage RequestDelete(RequestMessage requestMessage)
	0	464		{
	0	465		Guid guid = Guid.Parse(requestMessage.Path.Substring(AdminRequests.Length + 1));
		466
	0	467		if (DeleteLogEntry(guid))
	0	468		return new ResponseMessage { Body = "Request removed" };
		469
	0	470		return new ResponseMessage { Body = "Request not found" };
	0	471		}
		472		#endregion Request/{guid}
		473
		474		#region Requests
		475		private ResponseMessage RequestsGet(RequestMessage requestMessage)
	1	476		{
	1	477		var result = LogEntries
	2	478		.Where(r => !r.RequestMessage.Path.StartsWith("/__admin/"))
	1	479		.Select(ToLogEntryModel);
		480
	1	481		return ToJson(result);
	1	482		}
		483
		484		private LogEntryModel ToLogEntryModel(LogEntry logEntry)
	2	485		{
	2	486		return new LogEntryModel
	2	487		{
	2	488		Guid = logEntry.Guid,
	2	489		Request = new LogRequestModel
	2	490		{
	2	491		DateTime = logEntry.RequestMessage.DateTime,
	2	492		ClientIP = logEntry.RequestMessage.ClientIP,
	2	493		Path = logEntry.RequestMessage.Path,
	2	494		AbsoluteUrl = logEntry.RequestMessage.Url,
	2	495		Query = logEntry.RequestMessage.Query,
	2	496		Method = logEntry.RequestMessage.Method,
	2	497		Body = logEntry.RequestMessage.Body,
	2	498		BodyAsJson = logEntry.RequestMessage.BodyAsJson,
	2	499		BodyAsBytes = logEntry.RequestMessage.BodyAsBytes,
	2	500		Headers = logEntry.RequestMessage.Headers,
	2	501		Cookies = logEntry.RequestMessage.Cookies,
	2	502		BodyEncoding = logEntry.RequestMessage.BodyEncoding != null ? new EncodingModel
	2	503		{
	2	504		EncodingName = logEntry.RequestMessage.BodyEncoding.EncodingName,
	2	505		CodePage = logEntry.RequestMessage.BodyEncoding.CodePage,
	2	506		WebName = logEntry.RequestMessage.BodyEncoding.WebName
	2	507		} : null
	2	508		},
	2	509		Response = new LogResponseModel
	2	510		{
	2	511		StatusCode = logEntry.ResponseMessage.StatusCode,
	2	512		BodyDestination = logEntry.ResponseMessage.BodyDestination,
	2	513		Body = logEntry.ResponseMessage.Body,
	2	514		BodyAsJson = logEntry.ResponseMessage.BodyAsJson,
	2	515		BodyAsBytes = logEntry.ResponseMessage.BodyAsBytes,
	2	516		BodyOriginal = logEntry.ResponseMessage.BodyOriginal,
	2	517		BodyAsFile = logEntry.ResponseMessage.BodyAsFile,
	2	518		BodyAsFileIsCached = logEntry.ResponseMessage.BodyAsFileIsCached,
	2	519		Headers = logEntry.ResponseMessage.Headers,
	2	520		BodyEncoding = logEntry.ResponseMessage.BodyEncoding != null ? new EncodingModel
	2	521		{
	2	522		EncodingName = logEntry.ResponseMessage.BodyEncoding.EncodingName,
	2	523		CodePage = logEntry.ResponseMessage.BodyEncoding.CodePage,
	2	524		WebName = logEntry.ResponseMessage.BodyEncoding.WebName
	2	525		} : null
	2	526		},
	2	527		MappingGuid = logEntry.MappingGuid,
	2	528		MappingTitle = logEntry.MappingTitle,
	2	529		RequestMatchResult = logEntry.RequestMatchResult != null ? new LogRequestMatchModel
	2	530		{
	2	531		TotalScore = logEntry.RequestMatchResult.TotalScore,
	2	532		TotalNumber = logEntry.RequestMatchResult.TotalNumber,
	2	533		IsPerfectMatch = logEntry.RequestMatchResult.IsPerfectMatch,
	2	534		AverageTotalScore = logEntry.RequestMatchResult.AverageTotalScore,
	2	535		MatchDetails = logEntry.RequestMatchResult.MatchDetails.Select(x => new
	2	536		{
	2	537		Name = x.Key.Name.Replace("RequestMessage", string.Empty),
	2	538		Score = x.Value
	2	539		} as object).ToList()
	2	540		} : null
	2	541		};
	2	542		}
		543
		544		private ResponseMessage RequestsDelete(RequestMessage requestMessage)
	0	545		{
	0	546		ResetLogEntries();
		547
	0	548		return new ResponseMessage { Body = "Requests deleted" };
	0	549		}
		550		#endregion Requests
		551
		552		#region Requests/find
		553		private ResponseMessage RequestsFind(RequestMessage requestMessage)
	1	554		{
	1	555		var requestModel = requestMessage.Body != null ? JsonConvert.DeserializeObject<RequestModel>(requestMessage.
		556
	1	557		var request = (Request)InitRequestBuilder(requestModel);
		558
	1	559		var dict = new Dictionary<LogEntry, RequestMatchResult>();
	6	560		foreach (var logEntry in LogEntries.Where(le => !le.RequestMessage.Path.StartsWith("/__admin/")))
	1	561		{
	1	562		var requestMatchResult = new RequestMatchResult();
	1	563		if (request.GetMatchingScore(logEntry.RequestMessage, requestMatchResult) > MatchScores.AlmostPerfect)
	1	564		{
	1	565		dict.Add(logEntry, requestMatchResult);
	1	566		}
	1	567		}
		568
	3	569		var result = dict.OrderBy(x => x.Value.AverageTotalScore).Select(x => x.Key).Select(ToLogEntryModel);
		570
	1	571		return ToJson(result);
	1	572		}
		573		#endregion Requests/find
		574
		575		#region Scenarios
		576		private ResponseMessage ScenariosGet(RequestMessage requestMessage)
	0	577		{
	0	578		var scenarios = Scenarios.Select(s => new
	0	579		{
	0	580		Name = s.Key,
	0	581		Started = s.Value != null,
	0	582		NextState = s.Value
	0	583		});
	0	584		return ToJson(scenarios);
	0	585		}
		586
		587		private ResponseMessage ScenariosReset(RequestMessage requestMessage)
	0	588		{
	0	589		ResetScenarios();
		590
	0	591		return new ResponseMessage { Body = "Scenarios reset" };
	0	592		}
		593		#endregion
		594
		595		private IRequestBuilder InitRequestBuilder(RequestModel requestModel)
	6	596		{
	6	597		IRequestBuilder requestBuilder = Request.Create();
		598
	6	599		if (requestModel.ClientIP != null)
	0	600		{
	0	601		string clientIP = requestModel.ClientIP as string;
	0	602		if (clientIP != null)
	0	603		{
	0	604		requestBuilder = requestBuilder.WithClientIP(clientIP);
	0	605		}
		606		else
	0	607		{
	0	608		var clientIPModel = JsonUtils.ParseJTokenToObject<ClientIPModel>(requestModel.ClientIP);
	0	609		if (clientIPModel?.Matchers != null)
	0	610		{
	0	611		requestBuilder = requestBuilder.WithPath(clientIPModel.Matchers.Select(MatcherModelMapper.Map).C
	0	612		}
	0	613		}
	0	614		}
		615
	6	616		if (requestModel.Path != null)
	5	617		{
	5	618		string path = requestModel.Path as string;
	5	619		if (path != null)
	1	620		{
	1	621		requestBuilder = requestBuilder.WithPath(path);
	1	622		}
		623		else
	4	624		{
	4	625		var pathModel = JsonUtils.ParseJTokenToObject<PathModel>(requestModel.Path);
	4	626		if (pathModel?.Matchers != null)
	4	627		{
	4	628		requestBuilder = requestBuilder.WithPath(pathModel.Matchers.Select(MatcherModelMapper.Map).Cast<
	4	629		}
	4	630		}
	5	631		}
		632
	6	633		if (requestModel.Url != null)
	0	634		{
	0	635		string url = requestModel.Url as string;
	0	636		if (url != null)
	0	637		{
	0	638		requestBuilder = requestBuilder.WithUrl(url);
	0	639		}
		640		else
	0	641		{
	0	642		var urlModel = JsonUtils.ParseJTokenToObject<UrlModel>(requestModel.Url);
	0	643		if (urlModel?.Matchers != null)
	0	644		{
	0	645		requestBuilder = requestBuilder.WithUrl(urlModel.Matchers.Select(MatcherModelMapper.Map).Cast<IS
	0	646		}
	0	647		}
	0	648		}
		649
	6	650		if (requestModel.Methods != null)
	5	651		{
	5	652		requestBuilder = requestBuilder.UsingVerb(requestModel.Methods);
	5	653		}
		654
	6	655		if (requestModel.Headers != null)
	0	656		{
	0	657		foreach (var headerModel in requestModel.Headers.Where(h => h.Matchers != null))
	0	658		{
	0	659		requestBuilder = requestBuilder.WithHeader(headerModel.Name, headerModel.Matchers.Select(MatcherMode
	0	660		}
	0	661		}
		662
	6	663		if (requestModel.Cookies != null)
	0	664		{
	0	665		foreach (var cookieModel in requestModel.Cookies.Where(c => c.Matchers != null))
	0	666		{
	0	667		requestBuilder = requestBuilder.WithCookie(cookieModel.Name, cookieModel.Matchers.Select(MatcherMode
	0	668		}
	0	669		}
		670
	6	671		if (requestModel.Params != null)
	0	672		{
	0	673		foreach (var paramModel in requestModel.Params)
	0	674		{
	0	675		requestBuilder = paramModel.Values == null ? requestBuilder.WithParam(paramModel.Name) : requestBuil
	0	676		}
	0	677		}
		678
	6	679		if (requestModel.Body?.Matcher != null)
	2	680		{
	2	681		var bodyMatcher = MatcherModelMapper.Map(requestModel.Body.Matcher);
	2	682		requestBuilder = requestBuilder.WithBody(bodyMatcher);
	2	683		}
		684
	6	685		return requestBuilder;
	6	686		}
		687
		688		private IResponseBuilder InitResponseBuilder(ResponseModel responseModel)
	5	689		{
	5	690		IResponseBuilder responseBuilder = Response.Create();
		691
	5	692		if (responseModel.Delay > 0)
	0	693		{
	0	694		responseBuilder = responseBuilder.WithDelay(responseModel.Delay.Value);
	0	695		}
		696
	5	697		if (!string.IsNullOrEmpty(responseModel.ProxyUrl))
	0	698		{
	0	699		if (string.IsNullOrEmpty(responseModel.X509Certificate2ThumbprintOrSubjectName))
	0	700		{
	0	701		return responseBuilder.WithProxy(responseModel.ProxyUrl);
		702		}
		703
	0	704		return responseBuilder.WithProxy(responseModel.ProxyUrl, responseModel.X509Certificate2ThumbprintOrSubje
		705		}
		706
	5	707		if (responseModel.StatusCode.HasValue)
	5	708		{
	5	709		responseBuilder = responseBuilder.WithStatusCode(responseModel.StatusCode.Value);
	5	710		}
		711
	5	712		if (responseModel.Headers != null)
	4	713		{
	116	714		foreach (var entry in responseModel.Headers)
	52	715		{
	52	716		responseBuilder = entry.Value is string value ?
	52	717		responseBuilder.WithHeader(entry.Key, value) :
	52	718		responseBuilder.WithHeader(entry.Key, JsonUtils.ParseJTokenToObject<string[]>(entry.Value));
	52	719		}
	4	720		}
	1	721		else if (responseModel.HeadersRaw != null)
	0	722		{
	0	723		foreach (string headerLine in responseModel.HeadersRaw.Split(new[] { "\n", "\r\n" }, StringSplitOptions.
	0	724		{
	0	725		int indexColon = headerLine.IndexOf(":", StringComparison.Ordinal);
	0	726		string key = headerLine.Substring(0, indexColon).TrimStart(' ', '\t');
	0	727		string value = headerLine.Substring(indexColon + 1).TrimStart(' ', '\t');
	0	728		responseBuilder = responseBuilder.WithHeader(key, value);
	0	729		}
	0	730		}
		731
	5	732		if (responseModel.BodyAsBytes != null)
	0	733		{
	0	734		responseBuilder = responseBuilder.WithBody(responseModel.BodyAsBytes, responseModel.BodyDestination, ToE
	0	735		}
	5	736		else if (responseModel.Body != null)
	5	737		{
	5	738		responseBuilder = responseBuilder.WithBody(responseModel.Body, responseModel.BodyDestination, ToEncoding
	5	739		}
	0	740		else if (responseModel.BodyAsJson != null)
	0	741		{
	0	742		responseBuilder = responseBuilder.WithBodyAsJson(responseModel.BodyAsJson, ToEncoding(responseModel.Body
	0	743		}
	0	744		else if (responseModel.BodyFromBase64 != null)
	0	745		{
	0	746		responseBuilder = responseBuilder.WithBodyFromBase64(responseModel.BodyFromBase64, ToEncoding(responseMo
	0	747		}
		748
	5	749		if (responseModel.UseTransformer)
	0	750		{
	0	751		responseBuilder = responseBuilder.WithTransformer();
	0	752		}
		753
	5	754		return responseBuilder;
	5	755		}
		756
		757		private ResponseMessage ToJson<T>(T result)
	2	758		{
	2	759		return new ResponseMessage
	2	760		{
	2	761		Body = JsonConvert.SerializeObject(result, _settings),
	2	762		StatusCode = 200,
	2	763		Headers = new Dictionary<string, WireMockList<string>> { { HttpKnownHeaderNames.ContentType, new WireMoc
	2	764		};
	2	765		}
		766
		767		private Encoding ToEncoding(EncodingModel encodingModel)
	5	768		{
	5	769		return encodingModel != null ? Encoding.GetEncoding(encodingModel.CodePage) : null;
	5	770		}
		771		}
		772		}

C:\Users\azureuser\Documents\Github\WireMock.Net\src\WireMock.Net\Server\FluentMockServer.cs

	#	Line		Line coverage
		1		using System;
		2		using System.Collections.Concurrent;
		3		using System.Collections.Generic;
		4		using System.Linq;
		5		using System.Text;
		6		using System.Threading.Tasks;
		7		using JetBrains.Annotations;
		8		using Newtonsoft.Json;
		9		using WireMock.Http;
		10		using WireMock.Logging;
		11		using WireMock.Matchers;
		12		using WireMock.Matchers.Request;
		13		using WireMock.RequestBuilders;
		14		using WireMock.Settings;
		15		using WireMock.Validation;
		16		using WireMock.Owin;
		17		using WireMock.ResponseProviders;
		18
		19		namespace WireMock.Server
		20		{
		21		/// <summary>
		22		/// The fluent mock server.
		23		/// </summary>
		24		public partial class FluentMockServer : IDisposable
		25		{
		26		private readonly IWireMockLogger _logger;
		27		private const int ServerStartDelay = 100;
		28		private readonly IOwinSelfHost _httpServer;
	47	29		private readonly WireMockMiddlewareOptions _options = new WireMockMiddlewareOptions();
		30
		31		/// <summary>
		32		/// Gets a value indicating whether this server is started.
		33		/// </summary>
		34		[PublicAPI]
	0	35		public bool IsStarted { get; }
		36
		37		/// <summary>
		38		/// Gets the ports.
		39		/// </summary>
		40		[PublicAPI]
	29	41		public List<int> Ports { get; }
		42
		43		/// <summary>
		44		/// Gets the urls.
		45		/// </summary>
		46		[PublicAPI]
	74	47		public string[] Urls { get; }
		48
		49		/// <summary>
		50		/// Gets the mappings.
		51		/// </summary>
		52		[PublicAPI]
	12	53		public IEnumerable<Mapping> Mappings => _options.Mappings.Values.ToArray();
		54
		55		/// <summary>
		56		/// Gets the scenarios.
		57		/// </summary>
		58		[PublicAPI]
	0	59		public IDictionary<string, object> Scenarios => new ConcurrentDictionary<string, object>(_options.Scenarios);
		60
		61		#region Start/Stop
		62		/// <summary>
		63		/// Starts the specified settings.
		64		/// </summary>
		65		/// <param name="settings">The FluentMockServerSettings.</param>
		66		/// <returns>The <see cref="FluentMockServer"/>.</returns>
		67		[PublicAPI]
		68		public static FluentMockServer Start(IFluentMockServerSettings settings)
	4	69		{
	4	70		Check.NotNull(settings, nameof(settings));
		71
	4	72		return new FluentMockServer(settings);
	4	73		}
		74
		75		/// <summary>
		76		/// Start this FluentMockServer.
		77		/// </summary>
		78		/// <param name="port">The port.</param>
		79		/// <param name="ssl">The SSL support.</param>
		80		/// <returns>The <see cref="FluentMockServer"/>.</returns>
		81		[PublicAPI]
		82		public static FluentMockServer Start([CanBeNull] int? port = 0, bool ssl = false)
	40	83		{
	40	84		return new FluentMockServer(new FluentMockServerSettings
	40	85		{
	40	86		Port = port,
	40	87		UseSSL = ssl
	40	88		});
	40	89		}
		90
		91		/// <summary>
		92		/// Start this FluentMockServer.
		93		/// </summary>
		94		/// <param name="urls">The urls to listen on.</param>
		95		/// <returns>The <see cref="FluentMockServer"/>.</returns>
		96		[PublicAPI]
		97		public static FluentMockServer Start(params string[] urls)
	2	98		{
	2	99		Check.NotNullOrEmpty(urls, nameof(urls));
		100
	2	101		return new FluentMockServer(new FluentMockServerSettings
	2	102		{
	2	103		Urls = urls
	2	104		});
	2	105		}
		106
		107		/// <summary>
		108		/// Start this FluentMockServer with the admin interface.
		109		/// </summary>
		110		/// <param name="port">The port.</param>
		111		/// <param name="ssl">The SSL support.</param>
		112		/// <returns>The <see cref="FluentMockServer"/>.</returns>
		113		[PublicAPI]
		114		public static FluentMockServer StartWithAdminInterface(int? port = 0, bool ssl = false)
	1	115		{
	1	116		return new FluentMockServer(new FluentMockServerSettings
	1	117		{
	1	118		Port = port,
	1	119		UseSSL = ssl,
	1	120		StartAdminInterface = true
	1	121		});
	1	122		}
		123
		124		/// <summary>
		125		/// Start this FluentMockServer with the admin interface.
		126		/// </summary>
		127		/// <param name="urls">The urls.</param>
		128		/// <returns>The <see cref="FluentMockServer"/>.</returns>
		129		[PublicAPI]
		130		public static FluentMockServer StartWithAdminInterface(params string[] urls)
	0	131		{
	0	132		Check.NotNullOrEmpty(urls, nameof(urls));
		133
	0	134		return new FluentMockServer(new FluentMockServerSettings
	0	135		{
	0	136		Urls = urls,
	0	137		StartAdminInterface = true
	0	138		});
	0	139		}
		140
		141		/// <summary>
		142		/// Start this FluentMockServer with the admin interface and read static mappings.
		143		/// </summary>
		144		/// <param name="urls">The urls.</param>
		145		/// <returns>The <see cref="FluentMockServer"/>.</returns>
		146		[PublicAPI]
		147		public static FluentMockServer StartWithAdminInterfaceAndReadStaticMappings(params string[] urls)
	0	148		{
	0	149		Check.NotNullOrEmpty(urls, nameof(urls));
		150
	0	151		return new FluentMockServer(new FluentMockServerSettings
	0	152		{
	0	153		Urls = urls,
	0	154		StartAdminInterface = true,
	0	155		ReadStaticMappings = true
	0	156		});
	0	157		}
		158
	47	159		private FluentMockServer(IFluentMockServerSettings settings)
	47	160		{
	47	161		settings.Logger = settings.Logger ?? new WireMockConsoleLogger();
	47	162		_logger = settings.Logger;
		163
	47	164		_logger.Debug("WireMock.Net server settings {0}", JsonConvert.SerializeObject(settings, Formatting.Indented)
		165
	47	166		if (settings.Urls != null)
	2	167		{
	4	168		Urls = settings.Urls.Select(u => u.EndsWith("/") ? u : $"{u}/").ToArray();
	2	169		}
		170		else
	45	171		{
	45	172		int port = settings.Port > 0 ? settings.Port.Value : PortUtil.FindFreeTcpPort();
	45	173		Urls = new[] { (settings.UseSSL == true ? "https" : "http") + "://localhost:" + port + "/" };
	45	174		}
		175
	47	176		_options.PreWireMockMiddlewareInit = settings.PreWireMockMiddlewareInit;
	47	177		_options.PostWireMockMiddlewareInit = settings.PostWireMockMiddlewareInit;
	47	178		_options.Logger = _logger;
		179
		180		#if NETSTANDARD
		181		_httpServer = new AspNetCoreSelfHost(_options, Urls);
		182		#else
	47	183		_httpServer = new OwinSelfHost(_options, Urls);
		184		#endif
	47	185		Ports = _httpServer.Ports;
		186
	47	187		_httpServer.StartAsync();
		188
		189		// Fix for 'Bug: Server not listening after Start() returns (on macOS)'
	47	190		Task.Delay(ServerStartDelay).Wait();
		191
	47	192		IsStarted = _httpServer.IsStarted;
		193
	47	194		if (settings.AllowPartialMapping == true)
	0	195		{
	0	196		AllowPartialMapping();
	0	197		}
		198
	47	199		if (settings.StartAdminInterface == true)
	3	200		{
	3	201		if (!string.IsNullOrEmpty(settings.AdminUsername) && !string.IsNullOrEmpty(settings.AdminPassword))
	0	202		{
	0	203		SetBasicAuthentication(settings.AdminUsername, settings.AdminPassword);
	0	204		}
		205
	3	206		InitAdmin();
	3	207		}
		208
	47	209		if (settings.ReadStaticMappings == true)
	0	210		{
	0	211		ReadStaticMappings();
	0	212		}
		213
	47	214		if (settings.WatchStaticMappings == true)
	0	215		{
	0	216		WatchStaticMappings();
	0	217		}
		218
	47	219		if (settings.ProxyAndRecordSettings != null)
	2	220		{
	2	221		InitProxyAndRecord(settings.ProxyAndRecordSettings);
	2	222		}
		223
	47	224		if (settings.MaxRequestLogCount != null)
	0	225		{
	0	226		SetMaxRequestLogCount(settings.MaxRequestLogCount);
	0	227		}
	47	228		}
		229
		230		/// <summary>
		231		/// Stop this server.
		232		/// </summary>
		233		[PublicAPI]
		234		public void Stop()
	42	235		{
	42	236		_httpServer?.StopAsync();
	42	237		}
		238		#endregion
		239
		240		/// <summary>
		241		/// Adds the catch all mapping.
		242		/// </summary>
		243		[PublicAPI]
		244		public void AddCatchAllMapping()
	0	245		{
	0	246		Given(Request.Create().WithPath("/*").UsingAnyVerb())
	0	247		.WithGuid(Guid.Parse("90008000-0000-4444-a17e-669cd84f1f05"))
	0	248		.AtPriority(1000)
	0	249		.RespondWith(new DynamicResponseProvider(request => new ResponseMessage { StatusCode = 404, Body = "No m
	0	250		}
		251
		252		/// <summary>
		253		/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
		254		/// </summary>
		255		public void Dispose()
	5	256		{
	5	257		if (_httpServer != null && _httpServer.IsStarted)
	5	258		{
	5	259		_httpServer.StopAsync();
	5	260		}
	5	261		}
		262
		263		/// <summary>
		264		/// Resets LogEntries and Mappings.
		265		/// </summary>
		266		[PublicAPI]
		267		public void Reset()
	0	268		{
	0	269		ResetLogEntries();
		270
	0	271		ResetMappings();
	0	272		}
		273
		274		/// <summary>
		275		/// Resets the Mappings.
		276		/// </summary>
		277		[PublicAPI]
		278		public void ResetMappings()
	1	279		{
	6	280		foreach (var nonAdmin in _options.Mappings.Where(m => !m.Value.IsAdminInterface))
	1	281		{
	1	282		_options.Mappings.Remove(nonAdmin);
	1	283		}
	1	284		}
		285
		286		/// <summary>
		287		/// Deletes the mapping.
		288		/// </summary>
		289		/// <param name="guid">The unique identifier.</param>
		290		[PublicAPI]
		291		public bool DeleteMapping(Guid guid)
	0	292		{
		293		// Check a mapping exists with the same GUID, if so, remove it.
	0	294		if (_options.Mappings.ContainsKey(guid))
	0	295		{
	0	296		return _options.Mappings.Remove(guid);
		297		}
		298
	0	299		return false;
	0	300		}
		301
		302		private bool DeleteMapping(string path)
	0	303		{
		304		// Check a mapping exists with the same path, if so, remove it.
	0	305		var mapping = _options.Mappings.FirstOrDefault(entry => string.Equals(entry.Value.Path, path, StringComparis
	0	306		return DeleteMapping(mapping.Key);
	0	307		}
		308
		309		/// <summary>
		310		/// The add request processing delay.
		311		/// </summary>
		312		/// <param name="delay">The delay.</param>
		313		[PublicAPI]
		314		public void AddGlobalProcessingDelay(TimeSpan delay)
	1	315		{
	1	316		_options.RequestProcessingDelay = delay;
	1	317		}
		318
		319		/// <summary>
		320		/// Allows the partial mapping.
		321		/// </summary>
		322		[PublicAPI]
		323		public void AllowPartialMapping(bool allow = true)
	0	324		{
	0	325		_logger.Info("AllowPartialMapping is set to {0}", allow);
	0	326		_options.AllowPartialMapping = allow;
	0	327		}
		328
		329		/// <summary>
		330		/// Sets the basic authentication.
		331		/// </summary>
		332		/// <param name="username">The username.</param>
		333		/// <param name="password">The password.</param>
		334		[PublicAPI]
		335		public void SetBasicAuthentication([NotNull] string username, [NotNull] string password)
	0	336		{
	0	337		Check.NotNull(username, nameof(username));
	0	338		Check.NotNull(password, nameof(password));
		339
	0	340		string authorization = Convert.ToBase64String(Encoding.GetEncoding("ISO-8859-1").GetBytes(username + ":" + p
	0	341		_options.AuthorizationMatcher = new RegexMatcher("^(?i)BASIC " + authorization + "$");
	0	342		}
		343
		344		/// <summary>
		345		/// Removes the basic authentication.
		346		/// </summary>
		347		[PublicAPI]
		348		public void RemoveBasicAuthentication()
	0	349		{
	0	350		_options.AuthorizationMatcher = null;
	0	351		}
		352
		353		/// <summary>
		354		/// Sets the maximum RequestLog count.
		355		/// </summary>
		356		/// <param name="maxRequestLogCount">The maximum RequestLog count.</param>
		357		[PublicAPI]
		358		public void SetMaxRequestLogCount([CanBeNull] int? maxRequestLogCount)
	1	359		{
	1	360		_options.MaxRequestLogCount = maxRequestLogCount;
		361
	1	362		}
		363
		364		/// <summary>
		365		/// Sets RequestLog expiration in hours.
		366		/// </summary>
		367		/// <param name="requestLogExpirationDuration">The RequestLog expiration in hours.</param>
		368		[PublicAPI]
		369		public void SetRequestLogExpirationDuration([CanBeNull] int? requestLogExpirationDuration)
	0	370		{
	0	371		_options.RequestLogExpirationDuration = requestLogExpirationDuration;
	0	372		}
		373
		374		/// <summary>
		375		/// Resets the Scenarios.
		376		/// </summary>
		377		[PublicAPI]
		378		public void ResetScenarios()
	0	379		{
	0	380		_options.Scenarios.Clear();
	0	381		}
		382
		383		/// <summary>
		384		/// The given.
		385		/// </summary>
		386		/// <param name="requestMatcher">The request matcher.</param>
		387		/// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
		388		[PublicAPI]
		389		public IRespondWithAProvider Given(IRequestMatcher requestMatcher)
	103	390		{
	103	391		return new RespondWithAProvider(RegisterMapping, requestMatcher);
	103	392		}
		393
		394		private void RegisterMapping(Mapping mapping)
	103	395		{
		396		// Check a mapping exists with the same Guid, if so, replace it.
	103	397		if (_options.Mappings.ContainsKey(mapping.Guid))
	1	398		{
	1	399		_options.Mappings[mapping.Guid] = mapping;
	1	400		}
		401		else
	102	402		{
	102	403		_options.Mappings.Add(mapping.Guid, mapping);
	102	404		}
	103	405		}
		406		}
		407		}

C:\Users\azureuser\Documents\Github\WireMock.Net\src\WireMock.Net\Server\FluentMockServer.LogEntries.cs

	#	Line		Line coverage
		1		using System;
		2		using System.Collections;
		3		using System.Collections.Generic;
		4		using System.Collections.ObjectModel;
		5		using System.Collections.Specialized;
		6		using JetBrains.Annotations;
		7		using WireMock.Logging;
		8		using WireMock.Matchers.Request;
		9		using System.Linq;
		10		using WireMock.Matchers;
		11
		12		namespace WireMock.Server
		13		{
		14		public partial class FluentMockServer
		15		{
		16		/// <summary>
		17		/// Occurs when [log entries changed].
		18		/// </summary>
		19		[PublicAPI]
		20		public event NotifyCollectionChangedEventHandler LogEntriesChanged
		21		{
	2	22		add => _options.LogEntries.CollectionChanged += value;
	0	23		remove => _options.LogEntries.CollectionChanged -= value;
		24		}
		25
		26		/// <summary>
		27		/// Gets the request logs.
		28		/// </summary>
		29		[PublicAPI]
	14	30		public IEnumerable<LogEntry> LogEntries => new ReadOnlyCollection<LogEntry>(_options.LogEntries);
		31
		32		/// <summary>
		33		/// The search log-entries based on matchers.
		34		/// </summary>
		35		/// <param name="matchers">The matchers.</param>
		36		/// <returns>The <see cref="IEnumerable"/>.</returns>
		37		[PublicAPI]
		38		public IEnumerable<LogEntry> FindLogEntries([NotNull] params IRequestMatcher[] matchers)
	1	39		{
	1	40		var results = new Dictionary<LogEntry, RequestMatchResult>();
		41
	7	42		foreach (var log in _options.LogEntries)
	2	43		{
	2	44		var requestMatchResult = new RequestMatchResult();
	10	45		foreach (var matcher in matchers)
	2	46		{
	2	47		matcher.GetMatchingScore(log.RequestMessage, requestMatchResult);
	2	48		}
		49
	2	50		if (requestMatchResult.AverageTotalScore > MatchScores.AlmostPerfect)
	1	51		{
	1	52		results.Add(log, requestMatchResult);
	1	53		}
	2	54		}
		55
	3	56		return new ReadOnlyCollection<LogEntry>(results.OrderBy(x => x.Value).Select(x => x.Key).ToList());
	1	57		}
		58
		59		/// <summary>
		60		/// Resets the LogEntries.
		61		/// </summary>
		62		[PublicAPI]
		63		public void ResetLogEntries()
	1	64		{
	1	65		_options.LogEntries.Clear();
	1	66		}
		67
		68		/// <summary>
		69		/// Deletes a LogEntry.
		70		/// </summary>
		71		/// <param name="guid">The unique identifier.</param>
		72		[PublicAPI]
		73		public bool DeleteLogEntry(Guid guid)
	0	74		{
		75		// Check a logentry exists with the same GUID, if so, remove it.
	0	76		var existing = _options.LogEntries.FirstOrDefault(m => m.Guid == guid);
	0	77		if (existing != null)
	0	78		{
	0	79		_options.LogEntries.Remove(existing);
	0	80		return true;
		81		}
		82
	0	83		return false;
	0	84		}
		85		}
		86		}