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:	375
Uncovered lines:	352
Coverable lines:	727
Total lines:	1307
Line coverage:	51.5%
Branch coverage:	56.2%

Metrics

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

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

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

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]
	12	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()
	9	64		{
	9	65		_options.LogEntries.Clear();
	9	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		}